@agenticmail/enterprise 0.5.168 → 0.5.170

package/src/engine/agent-autonomy.ts

@@ -14,6 +14,60 @@ import type { EngineDatabase } from './db-adapter.js';
 
 // ─── Types ──────────────────────────────────────────────
 
+/**
+ * Autonomy settings — all configurable via dashboard.
+ * Stored in managed_agents.config.autonomy JSON field.
+ */
+export interface AutonomySettings {
+  /** Master switch — disables all autonomy features */
+  enabled: boolean;
+
+  /** Auto clock-in/out based on work schedule */
+  clockEnabled: boolean;
+
+  /**
+   * Daily/Weekly catchup: times are read from config.dailyCatchUp (Manager & Catch-Up tab).
+   * These booleans just enable/disable the behavior.
+   */
+  dailyCatchupEnabled: boolean;
+  weeklyCatchupEnabled: boolean;
+  weeklyCatchupDay: number;       // 0=Sun..6=Sat, default 1 (Monday)
+
+  /** Goal progress check */
+  goalCheckEnabled: boolean;
+  goalCheckHours: number[];       // hours of day to check, default [14, 17]
+
+  /** Knowledge contribution */
+  knowledgeContribEnabled: boolean;
+  knowledgeContribDay: number;    // 0=Sun..6=Sat, default 5 (Friday)
+  knowledgeContribHour: number;   // default 15
+
+  /** Smart escalation */
+  escalationEnabled: boolean;
+
+  /** Guardrail enforcement at runtime */
+  guardrailEnforcementEnabled: boolean;
+
+  /** Drive access request on 403 */
+  driveAccessRequestEnabled: boolean;
+}
+
+export const DEFAULT_AUTONOMY_SETTINGS: AutonomySettings = {
+  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,
+};
+
 export interface AutonomyConfig {
   agentId: string;
   orgId: string;
@@ -27,6 +81,7 @@ export interface AutonomyConfig {
   engineDb: EngineDatabase;
   memoryManager?: any;
   lifecycle?: any;
+  settings?: Partial<AutonomySettings>;
 }
 
 export interface ClockState {
@@ -49,6 +104,7 @@ interface CatchupData {
 
 export class AgentAutonomyManager {
   private config: AutonomyConfig;
+  private settings: AutonomySettings;
   private clockState: ClockState = { clockedIn: false };
   private schedulerInterval?: NodeJS.Timeout;
   private catchupInterval?: NodeJS.Timeout;
@@ -57,29 +113,68 @@ export class AgentAutonomyManager {
 
   constructor(config: AutonomyConfig) {
     this.config = config;
+    this.settings = { ...DEFAULT_AUTONOMY_SETTINGS, ...(config.settings || {}) };
+  }
+
+  /** Reload settings from DB (called when config changes via dashboard) */
+  async reloadSettings(): Promise<void> {
+    try {
+      const rows = await this.config.engineDb.query<any>(
+        `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 };
+          console.log('[autonomy] Settings reloaded from DB');
+        }
+      }
+    } catch (err: any) {
+      console.warn(`[autonomy] Failed to reload settings: ${err.message}`);
+    }
   }
 
+  getSettings(): AutonomySettings { return { ...this.settings }; }
+
   async start(): Promise<void> {
+    if (!this.settings.enabled) {
+      console.log('[autonomy] Disabled via settings, skipping');
+      return;
+    }
+
     console.log('[autonomy] Starting agent autonomy system...');
 
+    // Load latest settings from DB
+    await this.reloadSettings();
+
     // Check clock state on boot
-    await this.checkClockState();
+    if (this.settings.clockEnabled) await this.checkClockState();
 
     // Schedule checker runs every minute
-    this.schedulerInterval = setInterval(() => this.checkClockState(), 60_000);
+    this.schedulerInterval = setInterval(() => {
+      if (this.settings.clockEnabled) this.checkClockState();
+    }, 60_000);
 
-    // Catchup email checker runs every 30 minutes (checks if it's time for daily/weekly)
-    this.catchupInterval = setInterval(() => this.checkCatchupSchedule(), 30 * 60_000);
-    // Check immediately on start (after 30s delay for systems to settle)
+    // Catchup email checker runs every 15 minutes
+    this.catchupInterval = setInterval(() => this.checkCatchupSchedule(), 15 * 60_000);
     setTimeout(() => this.checkCatchupSchedule(), 30_000);
 
     // Knowledge contribution checker runs every hour
     this.knowledgeInterval = setInterval(() => this.checkKnowledgeContribution(), 60 * 60_000);
 
-    // Goal progress checker runs every 2 hours
-    this.goalCheckInterval = setInterval(() => this.checkGoalProgress(), 2 * 60 * 60_000);
+    // Goal progress checker runs every 30 minutes (more granular than 2h)
+    this.goalCheckInterval = setInterval(() => this.checkGoalProgress(), 30 * 60_000);
+
+    // Reload settings from DB every 10 minutes (picks up dashboard changes)
+    setInterval(() => this.reloadSettings(), 10 * 60_000);
 
-    console.log('[autonomy] System started — clock, catchup, knowledge, goals active');
+    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(): void {
@@ -182,20 +277,46 @@ export class AgentAutonomyManager {
   private async checkCatchupSchedule(): Promise<void> {
     if (!this.config.managerEmail || !this.config.runtime) return;
 
+    // Read catchup time from config.dailyCatchUp (set in Manager & Catch-Up tab)
+    let catchUpHour = 9;
+    let catchUpMinute = 0;
+    let catchUpTz = this.config.timezone || 'UTC';
+    try {
+      const rows = await this.config.engineDb.query<any>(
+        `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 dailyCatchUp is explicitly disabled in Manager tab, respect that
+        if (cfg.dailyCatchUp && cfg.dailyCatchUp.enabled === false) return;
+      }
+    } catch {}
+
     const now = new Date();
-    const tz = this.config.timezone || 'UTC';
-    const localTime = new Date(now.toLocaleString('en-US', { timeZone: tz }));
+    const localTime = new Date(now.toLocaleString('en-US', { timeZone: catchUpTz }));
     const hour = localTime.getHours();
     const minute = localTime.getMinutes();
-    const dayOfWeek = localTime.getDay(); // 0=Sun, 1=Mon
+    const dayOfWeek = localTime.getDay();
     const dateStr = localTime.toISOString().split('T')[0];
 
-    // Daily catchup: 9:00 AM on workdays (within first 30 min window)
-    const isDailyCatchupTime = hour === 9 && minute < 30;
-    // Weekly catchup: Monday 9:00 AM (within first 30 min window)
-    const isWeeklyCatchupTime = dayOfWeek === 1 && hour === 9 && minute < 30;
+    // Weekly catchup: configurable day, same time as daily
+    const isWeeklyCatchupTime = this.settings.weeklyCatchupEnabled
+      && dayOfWeek === this.settings.weeklyCatchupDay
+      && hour === catchUpHour
+      && minute >= catchUpMinute && minute < catchUpMinute + 15;
+
+    // Daily catchup: uses time from Manager & Catch-Up tab
+    const isDailyCatchupTime = this.settings.dailyCatchupEnabled
+      && hour === catchUpHour
+      && minute >= catchUpMinute && minute < catchUpMinute + 15;
 
-    if (!isDailyCatchupTime) return;
+    if (!isDailyCatchupTime && !isWeeklyCatchupTime) return;
 
     // Check if we already sent today's catchup
     const catchupKey = isWeeklyCatchupTime ? `weekly_catchup_${dateStr}` : `daily_catchup_${dateStr}`;
@@ -330,15 +451,16 @@ Available tools: gmail_send (to, subject, body), google_tasks_create (listId, ti
   // ─── 3. Goal Setting & Auto-Reminders ──────────────
 
   private async checkGoalProgress(): Promise<void> {
-    if (!this.config.runtime || !this.clockState.clockedIn) return;
+    if (!this.settings.goalCheckEnabled || !this.config.runtime || !this.clockState.clockedIn) return;
 
     const now = new Date();
     const tz = this.config.timezone || 'UTC';
     const localTime = new Date(now.toLocaleString('en-US', { timeZone: tz }));
     const hour = localTime.getHours();
 
-    // Check goals at 2 PM and 5 PM (end-of-day review)
-    if (hour !== 14 && hour !== 17) return;
+    // Check goals at configured hours
+    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}`;
@@ -348,7 +470,8 @@ Available tools: gmail_send (to, subject, body), google_tasks_create (listId, ti
     console.log(`[autonomy] Goal progress check at ${hour}:00`);
 
     try {
-      const prompt = hour === 17
+      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
@@ -365,7 +488,7 @@ Available tools: gmail_send (to, subject, body), google_tasks_create (listId, ti
       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 ${hour === 17 ? 'end-of-day' : 'mid-day'} goal review. Be thorough but efficient.`,
+        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] ✅ Goal check session ${session.id} created`);
       await this.setMemoryFlag(checkKey);
@@ -377,17 +500,17 @@ Available tools: gmail_send (to, subject, body), google_tasks_create (listId, ti
   // ─── 4. Knowledge Contribution (Friday) ────────────
 
   private async checkKnowledgeContribution(): Promise<void> {
-    if (!this.config.runtime || !this.clockState.clockedIn) return;
+    if (!this.settings.knowledgeContribEnabled || !this.config.runtime || !this.clockState.clockedIn) return;
 
     const now = new Date();
     const tz = this.config.timezone || 'UTC';
     const localTime = new Date(now.toLocaleString('en-US', { timeZone: tz }));
-    const dayOfWeek = localTime.getDay(); // 5=Friday
+    const dayOfWeek = localTime.getDay();
     const hour = localTime.getHours();
     const dateStr = localTime.toISOString().split('T')[0];
 
-    // Friday at 3 PM
-    if (dayOfWeek !== 5 || hour !== 15) return;
+    // Configurable day and hour
+    if (dayOfWeek !== this.settings.knowledgeContribDay || hour !== this.settings.knowledgeContribHour) return;
 
     const contribKey = `knowledge_contribution_${dateStr}`;
     const alreadyDone = await this.checkMemoryFlag(contribKey);