@agenticmail/enterprise 0.5.168 → 0.5.169

package/src/dashboard/pages/agent-detail.js

@@ -6410,6 +6410,227 @@ function ToolSecuritySection(props) {
 // AGENT DETAIL PAGE  (Main Orchestrator)
 // ════════════════════════════════════════════════════════════
 
+// ─── Autonomy Settings Section ──────────────────────────
+
+function AutonomySection(props) {
+  var agentId = props.agentId;
+  var engineAgent = props.engineAgent;
+  var reload = props.reload;
+  var app = useApp();
+  var toast = app.toast;
+
+  var defaults = {
+    enabled: true,
+    clockEnabled: true,
+    dailyCatchupEnabled: true, dailyCatchupHour: 9, dailyCatchupMinute: 0,
+    weeklyCatchupEnabled: true, weeklyCatchupDay: 1, weeklyCatchupHour: 9, weeklyCatchupMinute: 0,
+    goalCheckEnabled: true, goalCheckHours: [14, 17],
+    knowledgeContribEnabled: true, knowledgeContribDay: 5, knowledgeContribHour: 15,
+    escalationEnabled: true, guardrailEnforcementEnabled: true, driveAccessRequestEnabled: true,
+  };
+
+  var existing = (engineAgent?.config?.autonomy) || {};
+  var _form = useState(Object.assign({}, defaults, existing));
+  var form = _form[0]; var setForm = _form[1];
+  var _saving = useState(false);
+  var saving = _saving[0]; var setSaving = _saving[1];
+  var _dirty = useState(false);
+  var dirty = _dirty[0]; var setDirty = _dirty[1];
+
+  var set = function(key, val) {
+    var u = Object.assign({}, form);
+    u[key] = val;
+    setForm(u);
+    setDirty(true);
+  };
+
+  var save = function() {
+    setSaving(true);
+    var ea = engineAgent || {};
+    var isRunning = ea.state === 'running' || ea.state === 'active' || ea.state === 'degraded';
+    var endpoint = isRunning ? '/agents/' + agentId + '/hot-update' : '/agents/' + agentId + '/config';
+    var method = isRunning ? 'POST' : 'PATCH';
+    engineCall(endpoint, {
+      method: method,
+      body: JSON.stringify({ updates: { autonomy: form }, updatedBy: 'dashboard' })
+    }).then(function() {
+      toast('Autonomy settings saved' + (isRunning ? ' (agent will reload within 10 min)' : ''), 'success');
+      setDirty(false);
+      setSaving(false);
+      if (reload) reload();
+    }).catch(function(err) {
+      toast(err.message, 'error');
+      setSaving(false);
+    });
+  };
+
+  var DAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+
+  var toggleStyle = function(on) {
+    return {
+      width: 40, height: 22, borderRadius: 11,
+      background: on ? 'var(--success)' : 'var(--border)',
+      cursor: 'pointer', position: 'relative', flexShrink: 0,
+      transition: 'background 0.2s', display: 'inline-block',
+    };
+  };
+  var knobStyle = function(on) {
+    return {
+      width: 18, height: 18, borderRadius: '50%', background: '#fff',
+      position: 'absolute', top: 2, left: on ? 20 : 2,
+      transition: 'left 0.2s', boxShadow: '0 1px 3px rgba(0,0,0,0.2)',
+    };
+  };
+
+  var Toggle = function(p) {
+    return h('div', { style: { display: 'flex', alignItems: 'center', gap: 10 } },
+      h('div', { style: toggleStyle(p.value), onClick: function() { set(p.field, !p.value); } },
+        h('div', { style: knobStyle(p.value) })
+      ),
+      h('span', { style: { fontSize: 13, fontWeight: 500 } }, p.label),
+      p.desc && h('span', { style: { fontSize: 11, color: 'var(--text-muted)' } }, p.desc)
+    );
+  };
+
+  var TimeSelect = function(p) {
+    return h('div', { style: { display: 'flex', gap: 8, alignItems: 'center' } },
+      h('select', { className: 'input', style: { width: 80 }, value: p.hour, onChange: function(e) { set(p.hourField, parseInt(e.target.value)); } },
+        Array.from({length: 24}, function(_, i) {
+          var label = i === 0 ? '12 AM' : i < 12 ? i + ' AM' : i === 12 ? '12 PM' : (i - 12) + ' PM';
+          return h('option', { key: i, value: i }, label);
+        })
+      ),
+      h('span', null, ':'),
+      h('select', { className: 'input', style: { width: 65 }, value: p.minute, onChange: function(e) { set(p.minuteField, parseInt(e.target.value)); } },
+        [0, 15, 30, 45].map(function(m) { return h('option', { key: m, value: m }, String(m).padStart(2, '0')); })
+      )
+    );
+  };
+
+  var DaySelect = function(p) {
+    return h('select', { className: 'input', style: { width: 130 }, value: p.value, onChange: function(e) { set(p.field, parseInt(e.target.value)); } },
+      DAYS.map(function(d, i) { return h('option', { key: i, value: i }, d); })
+    );
+  };
+
+  var cardStyle = { marginBottom: 12 };
+  var rowStyle = { display: 'flex', justifyContent: 'space-between', alignItems: 'center', padding: '10px 16px', borderBottom: '1px solid var(--border)' };
+  var configRow = { display: 'flex', gap: 12, alignItems: 'center', padding: '8px 16px 8px 48px', borderBottom: '1px solid var(--border)', fontSize: 13 };
+
+  return h(Fragment, null,
+    // Header
+    h('div', { style: { display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 16 } },
+      h('div', null,
+        h('div', { style: { fontSize: 15, fontWeight: 600 } }, 'Agent Autonomy Settings'),
+        h('div', { style: { fontSize: 12, color: 'var(--text-muted)' } }, 'Configure automated behaviors — all times use agent timezone')
+      ),
+      h('div', { style: { display: 'flex', gap: 8 } },
+        dirty && h('span', { style: { fontSize: 11, color: 'var(--warning)', alignSelf: 'center' } }, 'Unsaved changes'),
+        h('button', { className: 'btn btn-primary btn-sm', disabled: !dirty || saving, onClick: save }, saving ? 'Saving...' : 'Save')
+      )
+    ),
+
+    // Master switch
+    h('div', { className: 'card', style: cardStyle },
+      h('div', { style: rowStyle },
+        h(Toggle, { field: 'enabled', value: form.enabled, label: 'Enable Autonomy System', desc: 'Master switch for all automated agent behaviors' })
+      )
+    ),
+
+    // Clock In/Out
+    h('div', { className: 'card', style: Object.assign({}, cardStyle, { opacity: form.enabled ? 1 : 0.5 }) },
+      h('div', { style: rowStyle },
+        h(Toggle, { field: 'clockEnabled', value: form.clockEnabled, label: 'Auto Clock-In/Out', desc: 'Clock in/out based on work schedule' })
+      ),
+      form.clockEnabled && h('div', { style: configRow },
+        h('span', { style: { color: 'var(--text-muted)' } }, 'Uses times from the Workforce tab schedule')
+      )
+    ),
+
+    // Daily Catchup
+    h('div', { className: 'card', style: Object.assign({}, cardStyle, { opacity: form.enabled ? 1 : 0.5 }) },
+      h('div', { style: rowStyle },
+        h(Toggle, { field: 'dailyCatchupEnabled', value: form.dailyCatchupEnabled, label: 'Daily Manager Catchup', desc: 'Email summary to manager each workday' })
+      ),
+      form.dailyCatchupEnabled && h('div', { style: configRow },
+        h('span', null, 'Send at'),
+        h(TimeSelect, { hour: form.dailyCatchupHour, minute: form.dailyCatchupMinute, hourField: 'dailyCatchupHour', minuteField: 'dailyCatchupMinute' })
+      )
+    ),
+
+    // Weekly Catchup
+    h('div', { className: 'card', style: Object.assign({}, cardStyle, { opacity: form.enabled ? 1 : 0.5 }) },
+      h('div', { style: rowStyle },
+        h(Toggle, { field: 'weeklyCatchupEnabled', value: form.weeklyCatchupEnabled, label: 'Weekly Manager Catchup', desc: 'Broader summary + goals, replaces daily on chosen day' })
+      ),
+      form.weeklyCatchupEnabled && h('div', { style: configRow },
+        h('span', null, 'Send on'),
+        h(DaySelect, { value: form.weeklyCatchupDay, field: 'weeklyCatchupDay' }),
+        h('span', null, 'at'),
+        h(TimeSelect, { hour: form.weeklyCatchupHour, minute: form.weeklyCatchupMinute, hourField: 'weeklyCatchupHour', minuteField: 'weeklyCatchupMinute' })
+      )
+    ),
+
+    // Goal Check
+    h('div', { className: 'card', style: Object.assign({}, cardStyle, { opacity: form.enabled ? 1 : 0.5 }) },
+      h('div', { style: rowStyle },
+        h(Toggle, { field: 'goalCheckEnabled', value: form.goalCheckEnabled, label: 'Goal Progress Checks', desc: 'Reviews Google Tasks at set hours (last = end-of-day review)' })
+      ),
+      form.goalCheckEnabled && h('div', { style: configRow },
+        h('span', null, 'Check at hours:'),
+        h('input', { className: 'input', style: { width: 150 },
+          value: (form.goalCheckHours || [14, 17]).join(', '),
+          placeholder: '14, 17',
+          onChange: function(e) {
+            var hrs = e.target.value.split(',').map(function(s) { return parseInt(s.trim()); }).filter(function(n) { return !isNaN(n) && n >= 0 && n <= 23; });
+            set('goalCheckHours', hrs.length > 0 ? hrs : [14, 17]);
+          }
+        }),
+        h('span', { style: { fontSize: 11, color: 'var(--text-muted)' } }, '(24h format, comma-separated)')
+      )
+    ),
+
+    // Knowledge Contribution
+    h('div', { className: 'card', style: Object.assign({}, cardStyle, { opacity: form.enabled ? 1 : 0.5 }) },
+      h('div', { style: rowStyle },
+        h(Toggle, { field: 'knowledgeContribEnabled', value: form.knowledgeContribEnabled, label: 'Weekly Knowledge Contribution', desc: 'Agent reviews learnings and contributes to role-based knowledge base' })
+      ),
+      form.knowledgeContribEnabled && h('div', { style: configRow },
+        h('span', null, 'Contribute on'),
+        h(DaySelect, { value: form.knowledgeContribDay, field: 'knowledgeContribDay' }),
+        h('span', null, 'at'),
+        h('select', { className: 'input', style: { width: 80 }, value: form.knowledgeContribHour, onChange: function(e) { set('knowledgeContribHour', parseInt(e.target.value)); } },
+          Array.from({length: 24}, function(_, i) {
+            var label = i === 0 ? '12 AM' : i < 12 ? i + ' AM' : i === 12 ? '12 PM' : (i - 12) + ' PM';
+            return h('option', { key: i, value: i }, label);
+          })
+        )
+      )
+    ),
+
+    // Smart Escalation
+    h('div', { className: 'card', style: Object.assign({}, cardStyle, { opacity: form.enabled ? 1 : 0.5 }) },
+      h('div', { style: rowStyle },
+        h(Toggle, { field: 'escalationEnabled', value: form.escalationEnabled, label: 'Smart Answer Escalation', desc: 'Search memory → Drive → escalate to manager when unsure' })
+      )
+    ),
+
+    // Guardrail Enforcement
+    h('div', { className: 'card', style: Object.assign({}, cardStyle, { opacity: form.enabled ? 1 : 0.5 }) },
+      h('div', { style: rowStyle },
+        h(Toggle, { field: 'guardrailEnforcementEnabled', value: form.guardrailEnforcementEnabled, label: 'Runtime Guardrail Enforcement', desc: 'Evaluate guardrail rules on inbound emails and tool calls' })
+      )
+    ),
+
+    // Drive Access Requests
+    h('div', { className: 'card', style: Object.assign({}, cardStyle, { opacity: form.enabled ? 1 : 0.5 }) },
+      h('div', { style: rowStyle },
+        h(Toggle, { field: 'driveAccessRequestEnabled', value: form.driveAccessRequestEnabled, label: 'Drive Access Requests', desc: 'When agent cannot access a file, it requests access from manager instead of failing silently' })
+      )
+    )
+  );
+}
+
 function AgentDetailPage(props) {
   var agentId = props.agentId;
   var onBack = props.onBack;
@@ -6430,8 +6651,8 @@ function AgentDetailPage(props) {
   var _agents = useState([]);
   var agents = _agents[0]; var setAgents = _agents[1];
 
-  var TABS = ['overview', 'personal', 'email', 'configuration', 'manager', 'tools', 'skills', 'permissions', 'activity', 'communication', 'workforce', 'memory', 'guardrails', 'budget', 'tool-security', 'deployment'];
-  var TAB_LABELS = { 'tool-security': 'Tool Security', 'manager': 'Manager & Catch-Up', 'email': 'Email', 'tools': 'Tools' };
+  var TABS = ['overview', 'personal', 'email', 'configuration', 'manager', 'tools', 'skills', 'permissions', 'activity', 'communication', 'workforce', 'memory', 'guardrails', 'autonomy', 'budget', 'tool-security', 'deployment'];
+  var TAB_LABELS = { 'tool-security': 'Tool Security', 'manager': 'Manager & Catch-Up', 'email': 'Email', 'tools': 'Tools', 'autonomy': 'Autonomy' };
 
   var load = function() {
     setLoading(true);
@@ -6563,6 +6784,7 @@ function AgentDetailPage(props) {
     tab === 'workforce' && h(WorkforceSection, { agentId: agentId }),
     tab === 'memory' && h(MemorySection, { agentId: agentId }),
     tab === 'guardrails' && h(GuardrailsSection, { agentId: agentId, agents: agents }),
+    tab === 'autonomy' && h(AutonomySection, { agentId: agentId, engineAgent: engineAgent, reload: load }),
     tab === 'budget' && h(BudgetSection, { agentId: agentId }),
     tab === 'tool-security' && h(ToolSecuritySection, { agentId: agentId }),
     tab === 'deployment' && h(DeploymentSection, { agentId: agentId, engineAgent: engineAgent, agent: agent, reload: load, onBack: onBack })

package/src/engine/agent-autonomy.ts

@@ -14,6 +14,67 @@ 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 catchup email to manager */
+  dailyCatchupEnabled: boolean;
+  dailyCatchupHour: number;       // 0-23, default 9
+  dailyCatchupMinute: number;     // 0-59, default 0
+
+  /** Weekly catchup email (broader summary + goals) */
+  weeklyCatchupEnabled: boolean;
+  weeklyCatchupDay: number;       // 0=Sun..6=Sat, default 1 (Monday)
+  weeklyCatchupHour: number;      // default 9
+  weeklyCatchupMinute: number;    // default 0
+
+  /** 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,
+  dailyCatchupHour: 9,
+  dailyCatchupMinute: 0,
+  weeklyCatchupEnabled: true,
+  weeklyCatchupDay: 1,
+  weeklyCatchupHour: 9,
+  weeklyCatchupMinute: 0,
+  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 +88,7 @@ export interface AutonomyConfig {
   engineDb: EngineDatabase;
   memoryManager?: any;
   lifecycle?: any;
+  settings?: Partial<AutonomySettings>;
 }
 
 export interface ClockState {
@@ -49,6 +111,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 +120,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@' + this.settings.dailyCatchupHour + ':' + String(this.settings.dailyCatchupMinute).padStart(2, '0'));
+    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 {
@@ -187,15 +289,21 @@ export class AgentAutonomyManager {
     const localTime = new Date(now.toLocaleString('en-US', { timeZone: tz }));
     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 + time
+    const isWeeklyCatchupTime = this.settings.weeklyCatchupEnabled
+      && dayOfWeek === this.settings.weeklyCatchupDay
+      && hour === this.settings.weeklyCatchupHour
+      && minute >= this.settings.weeklyCatchupMinute && minute < this.settings.weeklyCatchupMinute + 15;
+
+    // Daily catchup: configurable time (skip if weekly already covers it)
+    const isDailyCatchupTime = this.settings.dailyCatchupEnabled
+      && hour === this.settings.dailyCatchupHour
+      && minute >= this.settings.dailyCatchupMinute && minute < this.settings.dailyCatchupMinute + 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 +438,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 +457,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 +475,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 +487,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);