@agenticmail/enterprise 0.5.312 → 0.5.314

package/dist/agent-autonomy-PSXQ4MNP.js

@@ -0,0 +1,766 @@
+import "./chunk-KFQGP6VL.js";
+
+// src/engine/agent-autonomy.ts
+var DEFAULT_AUTONOMY_SETTINGS = {
+  enabled: true,
+  clockEnabled: true,
+  dailyCatchupEnabled: true,
+  weeklyCatchupEnabled: true,
+  weeklyCatchupDay: 1,
+  goalCheckEnabled: true,
+  goalCheckHours: [14, 17],
+  knowledgeContribEnabled: true,
+  knowledgeContribDay: 5,
+  knowledgeContribHour: 15,
+  escalationEnabled: true,
+  guardrailEnforcementEnabled: true,
+  driveAccessRequestEnabled: true
+};
+var AgentAutonomyManager = class {
+  config;
+  settings;
+  clockState = { clockedIn: false };
+  schedulerInterval;
+  catchupInterval;
+  knowledgeInterval;
+  goalCheckInterval;
+  constructor(config) {
+    this.config = config;
+    this.settings = { ...DEFAULT_AUTONOMY_SETTINGS, ...config.settings || {} };
+  }
+  /** Reload settings from DB (called when config changes via dashboard) */
+  async reloadSettings() {
+    try {
+      const rows = await this.config.engineDb.query(
+        `SELECT config FROM managed_agents WHERE id = $1`,
+        [this.config.agentId]
+      );
+      if (rows?.[0]?.config) {
+        const cfg = typeof rows[0].config === "string" ? JSON.parse(rows[0].config) : rows[0].config;
+        if (cfg.autonomy) {
+          this.settings = { ...DEFAULT_AUTONOMY_SETTINGS, ...cfg.autonomy };
+        }
+      }
+      const schedRows = await this.config.engineDb.query(
+        `SELECT config, timezone FROM work_schedules WHERE agent_id = $1 AND enabled = TRUE ORDER BY created_at DESC LIMIT 1`,
+        [this.config.agentId]
+      );
+      if (schedRows?.[0]) {
+        const schedConfig = typeof schedRows[0].config === "string" ? JSON.parse(schedRows[0].config) : schedRows[0].config;
+        if (schedConfig?.standardHours) {
+          this.config.schedule = {
+            start: schedConfig.standardHours.start,
+            end: schedConfig.standardHours.end,
+            days: schedConfig.standardHours.daysOfWeek || [1, 2, 3, 4, 5]
+          };
+          if (schedRows[0].timezone) this.config.timezone = schedRows[0].timezone;
+        }
+      }
+    } catch (err) {
+      console.warn(`[autonomy] Failed to reload settings: ${err.message}`);
+    }
+  }
+  getSettings() {
+    return { ...this.settings };
+  }
+  async start() {
+    if (!this.settings.enabled) {
+      console.log("[autonomy] Disabled via settings, skipping");
+      return;
+    }
+    console.log("[autonomy] Starting agent autonomy system...");
+    await this.reloadSettings();
+    if (this.settings.clockEnabled) await this.checkClockState();
+    this.schedulerInterval = setInterval(() => {
+      if (this.settings.clockEnabled) this.checkClockState();
+    }, 6e4);
+    this.catchupInterval = setInterval(() => this.checkCatchupSchedule(), 15 * 6e4);
+    setTimeout(() => this.checkCatchupSchedule(), 3e4);
+    this.knowledgeInterval = setInterval(() => this.checkKnowledgeContribution(), 60 * 6e4);
+    this.goalCheckInterval = setInterval(() => this.checkGoalProgress(), 30 * 6e4);
+    setInterval(() => this.reloadSettings(), 10 * 6e4);
+    const features = [];
+    if (this.settings.clockEnabled) features.push("clock");
+    if (this.settings.dailyCatchupEnabled) features.push("daily-catchup(time from Manager tab)");
+    if (this.settings.weeklyCatchupEnabled) features.push("weekly-catchup@" + ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"][this.settings.weeklyCatchupDay]);
+    if (this.settings.goalCheckEnabled) features.push("goals@" + this.settings.goalCheckHours.join(","));
+    if (this.settings.knowledgeContribEnabled) features.push("knowledge@" + ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"][this.settings.knowledgeContribDay]);
+    console.log("[autonomy] Active features: " + features.join(", "));
+  }
+  stop() {
+    if (this.schedulerInterval) clearInterval(this.schedulerInterval);
+    if (this.catchupInterval) clearInterval(this.catchupInterval);
+    if (this.knowledgeInterval) clearInterval(this.knowledgeInterval);
+    if (this.goalCheckInterval) clearInterval(this.goalCheckInterval);
+    console.log("[autonomy] System stopped");
+  }
+  // ─── 1. Auto Clock-In/Out ──────────────────────────
+  async checkClockState() {
+    const schedule = this.config.schedule;
+    if (!schedule) return;
+    const now = /* @__PURE__ */ new Date();
+    const tz = this.config.timezone || "UTC";
+    const localTime = new Date(now.toLocaleString("en-US", { timeZone: tz }));
+    const currentHour = localTime.getHours();
+    const currentMinute = localTime.getMinutes();
+    const currentDay = localTime.getDay();
+    const currentTimeStr = `${String(currentHour).padStart(2, "0")}:${String(currentMinute).padStart(2, "0")}`;
+    const isWorkday = schedule.days.includes(currentDay);
+    const isWithinHours = currentTimeStr >= schedule.start && currentTimeStr < schedule.end;
+    if (isWorkday && isWithinHours && !this.clockState.clockedIn) {
+      await this.clockIn();
+      await this.morningTriage();
+    } else if ((!isWorkday || !isWithinHours) && this.clockState.clockedIn) {
+      await this.clockOut();
+    }
+    this.clockState.lastCheckTime = now.toISOString();
+  }
+  async clockIn() {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.clockState.clockedIn = true;
+    this.clockState.clockInTime = now;
+    try {
+      await this.config.engineDb.execute(
+        `INSERT INTO clock_records (id, org_id, agent_id, type, triggered_by, actual_at, created_at) VALUES ($1, $2, $3, 'clock_in', 'auto_scheduler', $4, $4)`,
+        [crypto.randomUUID(), this.config.orgId, this.config.agentId, now]
+      );
+      console.log(`[autonomy] \u23F0 Clocked IN at ${now}`);
+      if (this.config.memoryManager) {
+        await this.config.memoryManager.storeMemory(this.config.agentId, {
+          content: `Clocked in at ${now}. Starting work shift.`,
+          category: "context",
+          importance: "low",
+          confidence: 1
+        }).catch(() => {
+        });
+      }
+    } catch (err) {
+      console.error(`[autonomy] Clock-in error: ${err.message}`);
+    }
+  }
+  async clockOut() {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.clockState.clockedIn = false;
+    this.clockState.clockOutTime = now;
+    try {
+      await this.config.engineDb.execute(
+        `INSERT INTO clock_records (id, org_id, agent_id, type, triggered_by, reason, actual_at, created_at) VALUES ($1, $2, $3, 'clock_out', 'auto_scheduler', 'End of scheduled hours', $4, $4)`,
+        [crypto.randomUUID(), this.config.orgId, this.config.agentId, now]
+      );
+      console.log(`[autonomy] \u23F0 Clocked OUT at ${now}`);
+      if (this.config.memoryManager) {
+        await this.config.memoryManager.storeMemory(this.config.agentId, {
+          content: `Clocked out at ${now}. Work shift ended.`,
+          category: "context",
+          importance: "low",
+          confidence: 1
+        }).catch(() => {
+        });
+      }
+    } catch (err) {
+      console.error(`[autonomy] Clock-out error: ${err.message}`);
+    }
+  }
+  /**
+   * Morning Triage — runs once after clock-in.
+   * Scans for off-hours accumulated items (emails, chats, failed sessions)
+   * and creates a single LLM session to triage everything into tasks.
+   * 
+   * This avoids the problem of 15 emails = 15 separate sessions.
+   * Instead: 1 triage session → creates Google Tasks → then handles them in order.
+   */
+  async morningTriage() {
+    if (!this.config.runtime) return;
+    const dateStr = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const triageKey = `morning_triage_${dateStr}`;
+    const alreadyDone = await this.checkMemoryFlag(triageKey);
+    if (alreadyDone) return;
+    console.log("[autonomy] \u{1F305} Morning triage \u2014 scanning off-hours accumulation...");
+    const db = this.config.engineDb;
+    const agentId = this.config.agentId;
+    let unhandledEmails = 0;
+    let failedSessions = 0;
+    let failedChats = 0;
+    try {
+      const lastClockOut = this.clockState.clockOutTime || new Date(Date.now() - 16 * 60 * 60 * 1e3).toISOString();
+      const emailRows = await db.query(
+        `SELECT COUNT(*) as cnt FROM agent_sessions 
+         WHERE agent_id = $1 AND created_at > $2 AND metadata::text LIKE '%email%'`,
+        [agentId, lastClockOut]
+      );
+      unhandledEmails = parseInt(emailRows?.[0]?.cnt || "0");
+      const failedRows = await db.query(
+        `SELECT COUNT(*) as cnt FROM agent_sessions 
+         WHERE agent_id = $1 AND status = 'failed' AND created_at > $2`,
+        [agentId, lastClockOut]
+      );
+      failedSessions = parseInt(failedRows?.[0]?.cnt || "0");
+      const chatRows = await db.query(
+        `SELECT COUNT(*) as cnt FROM agent_sessions 
+         WHERE agent_id = $1 AND status = 'failed' AND metadata::text LIKE '%chat%' AND created_at > $2`,
+        [agentId, lastClockOut]
+      );
+      failedChats = parseInt(chatRows?.[0]?.cnt || "0");
+    } catch {
+    }
+    const totalItems = unhandledEmails + failedSessions + failedChats;
+    if (totalItems === 0) {
+      console.log("[autonomy] \u{1F305} Morning triage: nothing accumulated overnight. Clean start!");
+      await this.setMemoryFlag(triageKey);
+      return;
+    }
+    console.log(`[autonomy] \u{1F305} Morning triage: ${unhandledEmails} emails, ${failedSessions} failed sessions, ${failedChats} failed chats`);
+    if (totalItems <= 3) {
+      console.log("[autonomy] \u{1F305} Only a few items \u2014 skipping triage session, they'll be handled individually.");
+      await this.setMemoryFlag(triageKey);
+      return;
+    }
+    const prompt = `Good morning! You just clocked in. Here's what accumulated while you were off:
+
+- ${unhandledEmails} email session(s) were created overnight
+- ${failedSessions} session(s) failed (may need retry)  
+- ${failedChats} chat message(s) may be unanswered
+
+Your morning routine:
+1. Check your inbox with gmail_search (unread only) \u2014 scan subjects and senders
+2. For each important email, create a Google Task: google_tasks_create with title, notes, and priority
+3. Check Google Chat for any unanswered messages: google_chat_list_messages
+4. For any failed sessions that look important, add them as tasks too
+5. Send your manager (${this.config.managerEmail}) a brief "starting my day" message listing your top priorities
+6. After triage, start working through tasks in priority order
+
+Prioritize: manager emails > urgent requests > routine items > FYI messages.
+Create tasks in a "Today" list so you can track progress throughout the day.`;
+    const systemPrompt = `You are ${this.config.agentName}, a ${this.config.role}. 
+You just clocked in for the day. Your first task is to triage everything that accumulated overnight.
+Be systematic: scan, prioritize, create tasks, then execute. Don't just dive into the first email you see.
+Work schedule: ${this.config.schedule ? `${this.config.schedule.start}-${this.config.schedule.end} ${this.config.timezone}` : "Standard hours"}`;
+    try {
+      const session = await this.config.runtime.spawnSession({
+        agentId,
+        message: prompt,
+        systemPrompt
+      });
+      console.log(`[autonomy] \u{1F305} Morning triage session ${session.id} created`);
+      await this.setMemoryFlag(triageKey);
+    } catch (err) {
+      console.error(`[autonomy] Morning triage error: ${err.message}`);
+    }
+  }
+  isWorkingHours() {
+    return this.clockState.clockedIn;
+  }
+  getClockState() {
+    return { ...this.clockState };
+  }
+  // ─── 2. Manager Catchup Emails ─────────────────────
+  async checkCatchupSchedule() {
+    if (!this.config.managerEmail || !this.config.runtime) return;
+    let catchUpHour = 9;
+    let catchUpMinute = 0;
+    let catchUpTz = this.config.timezone || "UTC";
+    try {
+      const rows = await this.config.engineDb.query(
+        `SELECT config FROM managed_agents WHERE id = $1`,
+        [this.config.agentId]
+      );
+      if (rows?.[0]?.config) {
+        const cfg = typeof rows[0].config === "string" ? JSON.parse(rows[0].config) : rows[0].config;
+        if (cfg.dailyCatchUp?.time) {
+          const parts = cfg.dailyCatchUp.time.split(":");
+          catchUpHour = parseInt(parts[0]) || 9;
+          catchUpMinute = parseInt(parts[1]) || 0;
+        }
+        if (cfg.dailyCatchUp?.timezone) catchUpTz = cfg.dailyCatchUp.timezone;
+        if (cfg.dailyCatchUp && cfg.dailyCatchUp.enabled === false) return;
+      }
+    } catch {
+    }
+    const now = /* @__PURE__ */ new Date();
+    const localTime = new Date(now.toLocaleString("en-US", { timeZone: catchUpTz }));
+    const hour = localTime.getHours();
+    const minute = localTime.getMinutes();
+    const dayOfWeek = localTime.getDay();
+    const dateStr = localTime.toISOString().split("T")[0];
+    const isWeeklyCatchupTime = this.settings.weeklyCatchupEnabled && dayOfWeek === this.settings.weeklyCatchupDay && hour === catchUpHour && minute >= catchUpMinute && minute < catchUpMinute + 15;
+    const isDailyCatchupTime = this.settings.dailyCatchupEnabled && hour === catchUpHour && minute >= catchUpMinute && minute < catchUpMinute + 15;
+    if (!isDailyCatchupTime && !isWeeklyCatchupTime) return;
+    const catchupKey = isWeeklyCatchupTime ? `weekly_catchup_${dateStr}` : `daily_catchup_${dateStr}`;
+    const alreadySent = await this.checkMemoryFlag(catchupKey);
+    if (alreadySent) return;
+    console.log(`[autonomy] ${isWeeklyCatchupTime ? "Weekly" : "Daily"} catchup time \u2014 generating report...`);
+    try {
+      const catchupData = await this.gatherCatchupData(isWeeklyCatchupTime ? 7 : 1);
+      await this.sendCatchupEmail(catchupData, isWeeklyCatchupTime);
+      await this.setMemoryFlag(catchupKey);
+    } catch (err) {
+      console.error(`[autonomy] Catchup email error: ${err.message}`);
+    }
+  }
+  async gatherCatchupData(daysBack) {
+    const since = new Date(Date.now() - daysBack * 24 * 60 * 60 * 1e3).toISOString();
+    const db = this.config.engineDb;
+    const agentId = this.config.agentId;
+    let emailsHandled = 0;
+    try {
+      const rows = await db.query(
+        `SELECT COUNT(*) as cnt FROM agent_memory WHERE agent_id = $1 AND category = 'processed_email' AND created_at >= $2`,
+        [agentId, since]
+      );
+      emailsHandled = rows?.[0]?.cnt || 0;
+    } catch {
+    }
+    let sessionsRun = 0;
+    try {
+      const rows = await db.query(
+        `SELECT COUNT(*) as cnt FROM agent_sessions WHERE agent_id = $1 AND created_at >= $2`,
+        [agentId, since]
+      );
+      sessionsRun = rows?.[0]?.cnt || 0;
+    } catch {
+    }
+    let memoriesStored = 0;
+    try {
+      const rows = await db.query(
+        `SELECT COUNT(*) as cnt FROM agent_memory WHERE agent_id = $1 AND created_at >= $2`,
+        [agentId, since]
+      );
+      memoriesStored = rows?.[0]?.cnt || 0;
+    } catch {
+    }
+    let tasksCompleted = [];
+    try {
+      const taskRows = await db.query(
+        `SELECT content FROM agent_memory WHERE agent_id = $1 AND category = 'skill' AND content LIKE '%task%complete%' AND created_at >= $2 ORDER BY created_at DESC LIMIT 10`,
+        [agentId, since]
+      );
+      tasksCompleted = (taskRows || []).map((r) => r.content?.slice(0, 200));
+    } catch {
+    }
+    let issuesEncountered = [];
+    try {
+      const issueRows = await db.query(
+        `SELECT content FROM agent_memory WHERE agent_id = $1 AND category = 'correction' AND created_at >= $2 ORDER BY created_at DESC LIMIT 5`,
+        [agentId, since]
+      );
+      issuesEncountered = (issueRows || []).map((r) => r.content?.slice(0, 200));
+    } catch {
+    }
+    let knowledgeGained = [];
+    try {
+      const knowRows = await db.query(
+        `SELECT content FROM agent_memory WHERE agent_id = $1 AND (category = 'skill' OR category = 'org_knowledge') AND created_at >= $2 ORDER BY created_at DESC LIMIT 10`,
+        [agentId, since]
+      );
+      knowledgeGained = (knowRows || []).map((r) => r.content?.slice(0, 200));
+    } catch {
+    }
+    return { emailsHandled, sessionsRun, memoriesStored, tasksCompleted, issuesEncountered, knowledgeGained };
+  }
+  async sendCatchupEmail(data, isWeekly) {
+    const runtime = this.config.runtime;
+    const managerEmail = this.config.managerEmail;
+    const agentName = this.config.agentName;
+    const role = this.config.role;
+    const period = isWeekly ? "last week" : "yesterday";
+    const nextPeriod = isWeekly ? "this week" : "today";
+    const prompt = `You need to send your ${isWeekly ? "weekly" : "daily"} catchup email to your manager at ${managerEmail}.
+
+Here's what you accomplished ${period}:
+- Emails handled: ${data.emailsHandled}
+- Sessions/conversations: ${data.sessionsRun}
+- Memories stored: ${data.memoriesStored}
+- Tasks completed: ${data.tasksCompleted.length > 0 ? data.tasksCompleted.join("; ") : "None tracked"}
+- Issues encountered: ${data.issuesEncountered.length > 0 ? data.issuesEncountered.join("; ") : "None"}
+- Knowledge gained: ${data.knowledgeGained.length > 0 ? data.knowledgeGained.join("; ") : "None tracked"}
+
+Write and send a concise, professional ${isWeekly ? "weekly" : "daily"} summary email. Include:
+1. What you accomplished ${period} (be specific, not generic)
+2. Any issues or blockers you encountered
+3. What you plan to focus on ${nextPeriod}
+${isWeekly ? "4. Goals for the week (create Google Tasks for each goal)" : ""}
+${isWeekly ? "5. Any suggestions for improvement or areas where you need guidance" : ""}
+
+Keep it under ${isWeekly ? "400" : "250"} words. Be genuine and specific \u2014 your manager reads these to stay informed.
+Use gmail_send to send the email. Subject: "${isWeekly ? "Weekly" : "Daily"} Update \u2014 ${agentName}"
+
+${isWeekly ? "After sending the email, create Google Tasks for your goals this week using google_tasks_create." : ""}`;
+    const systemPrompt = `You are ${agentName}, a ${role}. You are sending your ${isWeekly ? "weekly" : "daily"} catchup email to your manager.
+Be professional but genuine. Use real data from the summary \u2014 don't make up accomplishments.
+Available tools: gmail_send (to, subject, body), google_tasks_create (listId, title, notes, dueDate).`;
+    try {
+      const session = await runtime.spawnSession({
+        agentId: this.config.agentId,
+        message: prompt,
+        systemPrompt
+      });
+      console.log(`[autonomy] \u2705 ${isWeekly ? "Weekly" : "Daily"} catchup email session ${session.id} created`);
+    } catch (err) {
+      console.error(`[autonomy] Failed to send catchup email: ${err.message}`);
+    }
+  }
+  // ─── 3. Goal Setting & Auto-Reminders ──────────────
+  async checkGoalProgress() {
+    if (!this.settings.goalCheckEnabled || !this.config.runtime || !this.clockState.clockedIn) return;
+    const now = /* @__PURE__ */ new Date();
+    const tz = this.config.timezone || "UTC";
+    const localTime = new Date(now.toLocaleString("en-US", { timeZone: tz }));
+    const hour = localTime.getHours();
+    const goalHours = this.settings.goalCheckHours || [14, 17];
+    if (!goalHours.includes(hour)) return;
+    const dateStr = localTime.toISOString().split("T")[0];
+    const checkKey = `goal_check_${dateStr}_${hour}`;
+    const alreadyChecked = await this.checkMemoryFlag(checkKey);
+    if (alreadyChecked) return;
+    console.log(`[autonomy] Goal progress check at ${hour}:00`);
+    try {
+      const isEndOfDay = hour === Math.max(...goalHours);
+      const prompt = isEndOfDay ? `It's end of day. Review your goals and tasks:
+1. Call google_tasks_list to see your current tasks
+2. Review what you completed today
+3. Mark completed tasks as done with google_tasks_complete
+4. For incomplete tasks, update notes with progress
+5. Store a brief end-of-day reflection in memory about what went well and what to improve tomorrow
+6. If any task is blocked, email your manager at ${this.config.managerEmail || "your manager"} about it` : `Mid-day goal check:
+1. Call google_tasks_list to see your current tasks
+2. Review progress on today's priorities
+3. If you're behind on any task, adjust your approach
+4. Store any insights in memory for future reference`;
+      const session = await this.config.runtime.spawnSession({
+        agentId: this.config.agentId,
+        message: prompt,
+        systemPrompt: `You are ${this.config.agentName}, a ${this.config.role}. You are doing a ${isEndOfDay ? "end-of-day" : "mid-day"} goal review. Be thorough but efficient.`
+      });
+      console.log(`[autonomy] \u2705 Goal check session ${session.id} created`);
+      await this.setMemoryFlag(checkKey);
+    } catch (err) {
+      console.error(`[autonomy] Goal check error: ${err.message}`);
+    }
+  }
+  // ─── 4. Knowledge Contribution (Friday) ────────────
+  async checkKnowledgeContribution() {
+    if (!this.settings.knowledgeContribEnabled || !this.config.runtime || !this.clockState.clockedIn) return;
+    const now = /* @__PURE__ */ new Date();
+    const tz = this.config.timezone || "UTC";
+    const localTime = new Date(now.toLocaleString("en-US", { timeZone: tz }));
+    const dayOfWeek = localTime.getDay();
+    const hour = localTime.getHours();
+    const dateStr = localTime.toISOString().split("T")[0];
+    if (dayOfWeek !== this.settings.knowledgeContribDay || hour !== this.settings.knowledgeContribHour) return;
+    const contribKey = `knowledge_contribution_${dateStr}`;
+    const alreadyDone = await this.checkMemoryFlag(contribKey);
+    if (alreadyDone) return;
+    console.log("[autonomy] Friday knowledge contribution time!");
+    try {
+      const roleCategory = this.mapRoleToKnowledgeCategory(this.config.role);
+      const prompt = `It's Friday \u2014 time for your weekly knowledge contribution.
+
+Your role is ${this.config.role}, so focus on ${roleCategory} knowledge.
+
+Steps:
+1. Search your memory for key learnings this week: memory(action: "search", query: "learned this week")
+2. Search for tool patterns you discovered: memory(action: "search", query: "tool")
+3. Search for corrections and gotchas: memory(action: "search", query: "correction")
+4. Compile the most valuable learnings into knowledge entries
+5. For each entry, store it with a clear title and category:
+   - memory(action: "set", key: "knowledge-contrib-[topic]", value: "Clear description of the learning, including steps and examples", category: "org_knowledge", importance: "high")
+
+Categories to contribute to (pick the most relevant):
+${roleCategory === "support" ? "- customer-issues: Common customer problems and solutions\n- escalation-procedures: When and how to escalate\n- tool-patterns: Efficient ways to use tools\n- communication-templates: Effective response patterns" : ""}
+${roleCategory === "sales" ? "- objection-handling: How to address common objections\n- product-knowledge: Product features and benefits\n- prospect-research: Effective research methods" : ""}
+${roleCategory === "engineering" ? "- debugging-patterns: Common issues and fixes\n- architecture-decisions: Design choices and rationale\n- tool-expertise: Development tool tips" : ""}
+${roleCategory === "general" ? "- best-practices: General workflow improvements\n- tool-patterns: Tool usage tips\n- process-improvements: Better ways to do things" : ""}
+
+After storing knowledge entries, email your manager a brief summary of what you contributed.
+Aim for 3-5 high-quality entries. Quality over quantity.`;
+      const session = await this.config.runtime.spawnSession({
+        agentId: this.config.agentId,
+        message: prompt,
+        systemPrompt: `You are ${this.config.agentName}, a ${this.config.role}. You are contributing weekly knowledge to your organization's knowledge base. Focus on ${roleCategory}-related insights. Be specific and actionable \u2014 vague entries are useless.`
+      });
+      console.log(`[autonomy] \u2705 Knowledge contribution session ${session.id} created`);
+      await this.setMemoryFlag(contribKey);
+    } catch (err) {
+      console.error(`[autonomy] Knowledge contribution error: ${err.message}`);
+    }
+  }
+  mapRoleToKnowledgeCategory(role) {
+    const roleLower = (role || "").toLowerCase();
+    if (roleLower.includes("support") || roleLower.includes("customer") || roleLower.includes("service")) return "support";
+    if (roleLower.includes("sales") || roleLower.includes("business dev")) return "sales";
+    if (roleLower.includes("engineer") || roleLower.includes("developer") || roleLower.includes("technical")) return "engineering";
+    if (roleLower.includes("marketing") || roleLower.includes("content")) return "marketing";
+    if (roleLower.includes("hr") || roleLower.includes("human resource") || roleLower.includes("people")) return "hr";
+    if (roleLower.includes("finance") || roleLower.includes("accounting")) return "finance";
+    if (roleLower.includes("legal") || roleLower.includes("compliance")) return "legal";
+    if (roleLower.includes("research") || roleLower.includes("analyst")) return "research";
+    if (roleLower.includes("operations") || roleLower.includes("ops")) return "operations";
+    return "general";
+  }
+  // ─── 5. Smart Answer Escalation ────────────────────
+  /**
+   * Generates a system prompt addendum that teaches the agent the escalation workflow.
+   * This is injected into every email-handling session.
+   */
+  static getEscalationPrompt(managerEmail, orgDriveFolderId) {
+    return `
+== SMART ANSWER WORKFLOW (MANDATORY) ==
+When you receive a question or request you're not 100% confident about, follow this escalation chain:
+
+STEP 1: Search your own memory
+- memory(action: "search", query: "relevant keywords")
+- Check for similar past questions, corrections, and learned patterns
+
+STEP 2: Search organization Drive (shared knowledge)
+${orgDriveFolderId ? `- google_drive_list with query "fullText contains 'search terms'" and parents in '${orgDriveFolderId}'` : `- google_drive_list with query "fullText contains 'search terms'" to search shared docs`}
+- Read relevant documents with google_drive_get to find the answer
+- Check Google Sheets for data tables, Google Docs for procedures
+
+STEP 3: If still unsure \u2014 ESCALATE to manager
+${managerEmail ? `- Send an email to ${managerEmail} with:` : "- Send an email to your manager with:"}
+  Subject: "Need Guidance: [Brief topic]"
+  Body must include:
+  a) The original question/request (who asked, what they need)
+  b) What you found in your search (memory + Drive results)
+  c) Your proposed answer (what you THINK the answer should be)
+  d) What specifically you're unsure about
+  e) Ask for approval or correction before responding
+
+NEVER guess or fabricate an answer. It's better to escalate than to be wrong.
+
+After receiving manager feedback:
+- Store the correct answer in memory as a "correction" or "org_knowledge" entry
+- Apply the correction to your response
+- Thank the requester for their patience
+
+The goal: build confidence over time. Today you escalate often. In a month, you'll know most answers from memory.`;
+  }
+  // ─── Helper Methods ────────────────────────────────
+  async checkMemoryFlag(key) {
+    if (!this.config.memoryManager) return false;
+    try {
+      const results = await this.config.memoryManager.recall(this.config.agentId, key, 1);
+      return results.some((m) => m.content?.includes(key));
+    } catch {
+      try {
+        const rows = await this.config.engineDb.query(
+          `SELECT id FROM agent_memory WHERE agent_id = $1 AND content LIKE $2 LIMIT 1`,
+          [this.config.agentId, `%${key}%`]
+        );
+        return rows && rows.length > 0;
+      } catch {
+        return false;
+      }
+    }
+  }
+  async setMemoryFlag(key) {
+    if (!this.config.memoryManager) return;
+    try {
+      await this.config.memoryManager.storeMemory(this.config.agentId, {
+        content: `${key}: completed at ${(/* @__PURE__ */ new Date()).toISOString()}`,
+        category: "context",
+        importance: "low",
+        confidence: 1
+      });
+    } catch {
+    }
+  }
+};
+var GuardrailEnforcer = class {
+  engineDb;
+  rules = /* @__PURE__ */ new Map();
+  lastLoad = 0;
+  RELOAD_INTERVAL = 5 * 6e4;
+  // reload rules every 5 min
+  constructor(engineDb) {
+    this.engineDb = engineDb;
+  }
+  async ensureRulesLoaded() {
+    if (Date.now() - this.lastLoad < this.RELOAD_INTERVAL && this.rules.size > 0) return;
+    try {
+      const rows = await this.engineDb.query("SELECT * FROM guardrail_rules WHERE enabled = TRUE");
+      this.rules.clear();
+      for (const r of rows || []) {
+        this.rules.set(r.id, {
+          id: r.id,
+          orgId: r.org_id,
+          name: r.name,
+          category: r.category,
+          ruleType: r.rule_type,
+          conditions: typeof r.conditions === "string" ? JSON.parse(r.conditions) : r.conditions || {},
+          action: r.action,
+          severity: r.severity || "medium",
+          cooldownMinutes: r.cooldown_minutes || 0,
+          lastTriggeredAt: r.last_triggered_at,
+          triggerCount: r.trigger_count || 0
+        });
+      }
+      this.lastLoad = Date.now();
+    } catch (err) {
+      console.warn(`[guardrail-enforcer] Failed to load rules: ${err.message}`);
+    }
+  }
+  /**
+   * Check if an agent action should be blocked or flagged.
+   * Returns { allowed: true } or { allowed: false, reason, action }
+   */
+  async evaluate(event) {
+    await this.ensureRulesLoaded();
+    for (const rule of this.rules.values()) {
+      if (rule.conditions.agentIds?.length > 0 && !rule.conditions.agentIds.includes(event.agentId)) continue;
+      if (rule.orgId !== event.orgId) continue;
+      if (rule.lastTriggeredAt && rule.cooldownMinutes > 0) {
+        const cooldownUntil = new Date(rule.lastTriggeredAt).getTime() + rule.cooldownMinutes * 6e4;
+        if (Date.now() < cooldownUntil) continue;
+      }
+      const triggered = await this.evaluateRule(rule, event);
+      if (triggered) {
+        await this.recordTrigger(rule, event, triggered);
+        if (rule.action === "kill" || rule.action === "pause") {
+          return { allowed: false, reason: triggered, action: rule.action, ruleId: rule.id };
+        }
+        console.warn(`[guardrail-enforcer] Rule "${rule.name}" triggered: ${triggered} (action: ${rule.action})`);
+      }
+    }
+    return { allowed: true };
+  }
+  async evaluateRule(rule, event) {
+    switch (rule.ruleType) {
+      case "keyword_detection": {
+        if (!event.content) return null;
+        const keywords = rule.conditions.keywords || [];
+        const contentLower = event.content.toLowerCase();
+        for (const kw of keywords) {
+          if (contentLower.includes(kw.toLowerCase())) {
+            return `Keyword detected: "${kw}" in ${event.type}`;
+          }
+        }
+        return null;
+      }
+      case "prompt_injection": {
+        if (!event.content) return null;
+        const patterns = rule.conditions.patterns || [
+          "ignore previous",
+          "ignore all previous",
+          "disregard your instructions",
+          "you are now",
+          "new instructions:",
+          "system prompt:",
+          "forget everything",
+          "override your"
+        ];
+        const contentLower = event.content.toLowerCase();
+        for (const pattern of patterns) {
+          if (contentLower.includes(pattern.toLowerCase())) {
+            return `Potential prompt injection detected: "${pattern}"`;
+          }
+        }
+        return null;
+      }
+      case "data_leak_attempt": {
+        if (!event.content) return null;
+        const patterns = rule.conditions.patterns || [
+          "\\b\\d{3}-\\d{2}-\\d{4}\\b",
+          // SSN
+          "\\b\\d{4}[- ]?\\d{4}[- ]?\\d{4}[- ]?\\d{4}\\b",
+          // Credit card
+          "\\bpassword\\s*[:=]\\s*\\S+"
+          // Password in text
+        ];
+        for (const pattern of patterns) {
+          try {
+            if (new RegExp(pattern, "i").test(event.content)) {
+              return `Potential data leak: pattern "${pattern}" matched`;
+            }
+          } catch {
+          }
+        }
+        return null;
+      }
+      case "off_hours": {
+        if (event.type !== "session_start" && event.type !== "tool_call") return null;
+        try {
+          const schedRows = await this.engineDb.query(
+            `SELECT * FROM work_schedules WHERE agent_id = $1 ORDER BY created_at DESC LIMIT 1`,
+            [event.agentId]
+          );
+          if (schedRows && schedRows.length > 0) {
+            const sched = schedRows[0];
+            const config = typeof sched.config === "string" ? JSON.parse(sched.config) : sched.config || {};
+            const hours = config.standardHours;
+            if (hours?.start && hours?.end) {
+              const tz = config.timezone || "UTC";
+              const localTime = new Date((/* @__PURE__ */ new Date()).toLocaleString("en-US", { timeZone: tz }));
+              const currentHour = `${String(localTime.getHours()).padStart(2, "0")}:${String(localTime.getMinutes()).padStart(2, "0")}`;
+              if (currentHour < hours.start || currentHour >= hours.end) {
+                return `Activity outside work hours (${hours.start}-${hours.end} ${tz})`;
+              }
+            }
+          }
+        } catch {
+        }
+        return null;
+      }
+      case "memory_flood": {
+        if (event.type !== "memory_write") return null;
+        const maxPerHour = rule.conditions.maxPerHour || 50;
+        try {
+          const since = new Date(Date.now() - 60 * 6e4).toISOString();
+          const rows = await this.engineDb.query(
+            `SELECT COUNT(*) as cnt FROM agent_memory WHERE agent_id = $1 AND created_at >= $2`,
+            [event.agentId, since]
+          );
+          const count = rows?.[0]?.cnt || 0;
+          if (count > maxPerHour) {
+            return `Memory flood: ${count} writes in last hour (max: ${maxPerHour})`;
+          }
+        } catch {
+        }
+        return null;
+      }
+      case "tone_violation": {
+        if (!event.content || event.type !== "email_send") return null;
+        const keywords = rule.conditions.keywords || ["urgent", "asap", "immediately"];
+        const contentLower = event.content.toLowerCase();
+        let violations = 0;
+        for (const kw of keywords) {
+          if (contentLower.includes(kw.toLowerCase())) violations++;
+        }
+        if (violations >= (rule.conditions.threshold || 2)) {
+          return `Tone issue: ${violations} flagged words in outgoing email`;
+        }
+        return null;
+      }
+      default:
+        return null;
+    }
+  }
+  async recordTrigger(rule, event, detail) {
+    try {
+      await this.engineDb.execute(
+        `UPDATE guardrail_rules SET trigger_count = trigger_count + 1, last_triggered_at = $1 WHERE id = $2`,
+        [(/* @__PURE__ */ new Date()).toISOString(), rule.id]
+      );
+      rule.triggerCount = (rule.triggerCount || 0) + 1;
+      rule.lastTriggeredAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.engineDb.execute(
+        `INSERT INTO interventions (id, org_id, agent_id, type, reason, triggered_by, metadata, created_at) VALUES ($1, $2, $3, 'anomaly_detected', $4, 'guardrail_enforcer', $5, $6)`,
+        [
+          crypto.randomUUID(),
+          rule.orgId,
+          event.agentId,
+          `Rule "${rule.name}": ${detail}`,
+          JSON.stringify({ ruleId: rule.id, ruleType: rule.ruleType, eventType: event.type, severity: rule.severity }),
+          (/* @__PURE__ */ new Date()).toISOString()
+        ]
+      );
+    } catch (err) {
+      console.warn(`[guardrail-enforcer] Failed to record trigger: ${err.message}`);
+    }
+  }
+};
+export {
+  AgentAutonomyManager,
+  DEFAULT_AUTONOMY_SETTINGS,
+  GuardrailEnforcer
+};