@agenticmail/enterprise 0.5.441 → 0.5.443

package/CHANGELOG.md

@@ -2,6 +2,40 @@
 
 All notable changes to AgenticMail Enterprise are documented here.
 
+## [0.5.443] - 2026-03-11
+
+### Added
+- **Trading Optimizer Suite** — 6 new high-frequency trading tools (`polymarket-optimizer` skill):
+  - `poly_daily_scorecard` — Real-time P&L vs daily target, win rate, capital utilization, trading status (AHEAD/ON_TRACK/BEHIND/TARGET_HIT/STOP_TRADING)
+  - `poly_momentum_scanner` — Find markets with significant price movement in real-time; replaces static search for discovering active opportunities
+  - `poly_quick_edge` — One-call GO/NO-GO trade decision with edge %, Kelly size, and action (STRONG_BUY/BUY/MARGINAL/NO_TRADE/SELL); replaces 6+ separate tool calls
+  - `poly_position_heatmap` — All positions ranked by urgency (CRITICAL/HIGH/MEDIUM/LOW) with specific action needed for each
+  - `poly_profit_lock` — Auto-conservative mode after hitting daily target; returns adjusted position sizes and trading mode
+  - `poly_capital_recycler` — Redeploy freed capital to best opportunities after position closes; keeps capital working
+- **Daily Scorecard Dashboard** — New section in Polymarket Overview tab showing real-time daily P&L progress bar, target tracking, realized/unrealized P&L, trade count, win rate, and available capital
+- **Daily Scorecard API** — `GET /polymarket/:agentId/daily-scorecard` endpoint returning comprehensive daily trading metrics
+- **Browser Market Discovery** — Agents can browse polymarket.com to find market IDs when API returns stale results (system prompt guidance, no login required)
+- **Universal Message Trimmer** — Extracted stale aging + inline truncation into standalone `message-trimmer.ts` module; applies to ALL tools (web, browser, email, polymarket) not just polymarket
+- **Market Freshness Tracking** — Per-agent tracking of recently-analyzed markets with 30-min TTL; prevents agents from repeatedly analyzing the same stale markets
+- **Dead Market Filtering** — Markets with all-zero prices, zero liquidity, or resolved status are automatically filtered from search/screen results
+- **CLOB Rate Limit Resilience** — Gamma API fallbacks for orderbook depth, whale tracking, flow analysis, and price discovery when CLOB API is rate-limited
+- **Cross-DB Date Helpers** — `dateAgo()`, `dateAgoMin()`, `dateAhead()` for watcher SQL queries; replaces PostgreSQL-specific `::timestamptz`/`INTERVAL` syntax
+- **Comprehensive Topic Extraction** — `extractTopics()` expanded from 6 patterns to 25+ groups covering US/global politics, crypto, sports, AI, regulation, and more
+
+### Fixed
+- **PostgreSQL-only SQL in watcher** — Fixed 15+ queries using `::timestamptz`, `NOW()`, `INTERVAL` that failed on SQLite; all now use parameterized ISO date strings
+- **PostgreSQL DDL in portfolio** — Fixed `SERIAL PRIMARY KEY` → `INTEGER PRIMARY KEY AUTOINCREMENT` and `TIMESTAMPTZ` → `TEXT`
+- **Dead CLOB endpoints** — Replaced 3 dead `CLOB_API/markets/` calls with working `GAMMA_API/markets?clob_token_ids=` in watcher
+- **`poly_approve_trade`** — Fixed trade fetching AFTER resolution (trade disappeared); now fetches BEFORE resolving
+- **`poly_place_batch_orders`** — Fixed tool that validated but never executed orders; now creates pending trades and executes in autonomous mode
+- **`poly_resolution_risk` "Market not found"** — Auto-detects 0x condition IDs passed as slug parameter; added Gamma search fallback
+- **`poly_quick_analysis` null values** — Added fallback data when CLOB is rate-limited instead of returning null for orderbook/regime/kelly
+- **`poly_get_open_orders` / `poly_get_order`** — Fixed to check database as fallback, not just in-memory Map
+- **`poly_leaderboard` / `poly_top_holders`** — Fixed dead Gamma endpoints; now uses data-api fallback
+- **Proactive wake channel routing** — Uses manager's configured communication channel (telegram/whatsapp/email) instead of hardcoded values
+- **Hardcoded identity in proactive wake** — Replaced hardcoded `senderName: 'Ope'` with dynamic manager info
+- **Unused code cleanup** — Removed `_TradingConfig`, `PriceAlert`, `PaperPosition` interfaces, `priceAlerts`/`paperPositions`/`autoApproveRules` Maps, `getConfig()`/`checkAutoApprove()` functions, `_pricingCache` from agent-loop
+
 ## [0.5.320] - 2026-03-05
 
 ### Added

package/README.md

@@ -575,11 +575,12 @@ Gmail · Calendar · Drive · Docs · Sheets · Slides · Forms · Meet · Chat
 ### Microsoft 365 Suite (13 services, 90+ tools)
 Outlook Mail (20 tools) · Outlook Calendar (7) · Teams (15) · OneDrive (12) · Excel (16) · SharePoint (10) · OneNote (6) · Planner (6) · To Do (6) · PowerPoint (5) · Power BI (8) · Contacts (5) · Each with dedicated system prompts and Graph API integration with retry, rate-limit handling, pagination, and batch support.
 
-### Polymarket Trading Suite (9 skills, 108 tools)
+### Polymarket Trading Suite (10 skills, 114+ tools)
 Institutional-grade prediction market trading on [Polymarket](https://polymarket.com):
 - **polymarket** (63 tools) — Trading infrastructure, orders, wallet, risk controls, learning system
 - **polymarket-quant** (14) — Kelly criterion, Black-Scholes, Bayesian, Monte Carlo, RSI/MACD/Bollinger, VaR
 - **polymarket-onchain** (6) — Whale tracking, orderbook depth, on-chain flow, wallet profiling, liquidity mapping
+- **polymarket-optimizer** (6) — Daily scorecard, momentum scanner, quick edge, position heatmap, profit lock, capital recycler
 - **polymarket-social** (5) — Twitter/Reddit/Telegram sentiment, Polymarket comments, social velocity
 - **polymarket-feeds** (5) — Event calendar, official sources (SCOTUS/SEC/Fed/ESPN), odds aggregation, breaking news
 - **polymarket-analytics** (5) — Market correlation, arbitrage scanning, regime detection, smart money index
@@ -587,7 +588,7 @@ Institutional-grade prediction market trading on [Polymarket](https://polymarket
 - **polymarket-counterintel** (3) — Manipulation detection, resolution risk scoring, counterparty analysis
 - **polymarket-portfolio** (3) — Portfolio optimization, drawdown monitoring, P&L attribution
 
-Full dashboard with 17 tabs, dedicated system prompt, auto-SDK install, 25+ DB tables, SSE real-time updates.
+Full dashboard with daily scorecard, 22 tabs, dedicated system prompt, auto-SDK install, 25+ DB tables, SSE real-time updates.
 
 ### Enterprise Custom Suite (16+)
 Calendar · Code Sandbox · Database · Diff · Documents · Finance · HTTP · Knowledge Search · Logs · Notifications · Security Scan · Spreadsheet · Translation · Vision · Web Research · Workflow

package/dist/agent-heartbeat-QJ3WTWUK.js

@@ -0,0 +1,518 @@
+import "./chunk-KFQGP6VL.js";
+
+// src/engine/agent-heartbeat.ts
+var DEFAULT_SETTINGS = {
+  enabled: true,
+  baseIntervalMs: 5 * 6e4,
+  // 5 minutes
+  maxIntervalMs: 30 * 6e4,
+  // 30 minutes
+  dampingFactor: 0.5,
+  maxBatchSize: 5,
+  quietHoursStart: 23,
+  quietHoursEnd: 8
+};
+function createUnreadEmailCheck() {
+  return {
+    id: "unread_emails",
+    name: "Unread Emails",
+    intervalMs: 10 * 6e4,
+    // 10 minutes
+    priority: "high",
+    requiresClockIn: false,
+    // emails can be urgent outside hours
+    consecutiveNoOps: 0,
+    enabled: true,
+    check: async (ctx) => {
+      try {
+        const rows = await ctx.db.query(
+          `SELECT COUNT(*) as cnt FROM agent_memory 
+           WHERE agent_id = $1 
+           AND category = 'processed_email' 
+           AND created_at > NOW() - INTERVAL '4 hours'`,
+          [ctx.agentId]
+        );
+        const processedRecently = parseInt(rows?.[0]?.cnt || "0");
+        const lastProcessed = await ctx.db.query(
+          `SELECT MAX(created_at) as last_at FROM agent_memory 
+           WHERE agent_id = $1 AND category = 'processed_email'`,
+          [ctx.agentId]
+        );
+        const lastAt = lastProcessed?.[0]?.last_at;
+        if (ctx.isWorkHours && processedRecently === 0 && ctx.hour >= 10) {
+          return {
+            needsAction: true,
+            summary: "No emails processed in the last 4 hours during work hours. Check inbox.",
+            priority: "medium",
+            data: { lastProcessedAt: lastAt }
+          };
+        }
+        return { needsAction: false, priority: "low" };
+      } catch {
+        return { needsAction: false, priority: "low" };
+      }
+    }
+  };
+}
+function createUpcomingEventsCheck() {
+  return {
+    id: "upcoming_events",
+    name: "Upcoming Calendar Events",
+    intervalMs: 15 * 6e4,
+    // 15 minutes
+    priority: "high",
+    requiresClockIn: false,
+    consecutiveNoOps: 0,
+    enabled: true,
+    check: async (ctx) => {
+      try {
+        const _twoHoursFromNow = new Date(ctx.now.getTime() + 2 * 60 * 60 * 1e3).toISOString();
+        const rows = await ctx.db.query(
+          `SELECT content FROM agent_memory 
+           WHERE agent_id = $1 
+           AND category = 'context' 
+           AND content LIKE '%meeting%' 
+           AND created_at > NOW() - INTERVAL '24 hours'
+           ORDER BY created_at DESC LIMIT 5`,
+          [ctx.agentId]
+        );
+        const upcomingMeetings = (rows || []).filter((r) => {
+          const content = r.content || "";
+          return content.includes("meeting") || content.includes("event");
+        });
+        if (upcomingMeetings.length > 0) {
+          return {
+            needsAction: true,
+            summary: `${upcomingMeetings.length} potential upcoming event(s). Agent should check Google Calendar.`,
+            priority: "high",
+            data: { count: upcomingMeetings.length }
+          };
+        }
+        return { needsAction: false, priority: "low" };
+      } catch {
+        return { needsAction: false, priority: "low" };
+      }
+    }
+  };
+}
+function createStaleSessionsCheck() {
+  return {
+    id: "stale_sessions",
+    name: "Stale Sessions",
+    intervalMs: 30 * 6e4,
+    // 30 minutes
+    priority: "medium",
+    requiresClockIn: true,
+    consecutiveNoOps: 0,
+    enabled: true,
+    check: async (ctx) => {
+      try {
+        const rows = await ctx.db.query(
+          `SELECT COUNT(*) as cnt FROM agent_sessions 
+           WHERE agent_id = $1 
+           AND status = 'active' 
+           AND updated_at < NOW() - INTERVAL '2 hours'`,
+          [ctx.agentId]
+        );
+        const staleCount = parseInt(rows?.[0]?.cnt || "0");
+        if (staleCount > 0) {
+          return {
+            needsAction: true,
+            summary: `${staleCount} stale session(s) detected (active > 2 hours with no updates). May need cleanup.`,
+            priority: "medium",
+            data: { staleCount }
+          };
+        }
+        return { needsAction: false, priority: "low" };
+      } catch {
+        return { needsAction: false, priority: "low" };
+      }
+    }
+  };
+}
+function createMemoryHealthCheck() {
+  return {
+    id: "memory_health",
+    name: "Memory Health",
+    intervalMs: 60 * 6e4,
+    // 1 hour
+    priority: "low",
+    requiresClockIn: true,
+    consecutiveNoOps: 0,
+    enabled: true,
+    check: async (ctx) => {
+      try {
+        const rows = await ctx.db.query(
+          `SELECT COUNT(*) as cnt FROM agent_memory 
+           WHERE agent_id = $1 AND created_at > NOW() - INTERVAL '24 hours'`,
+          [ctx.agentId]
+        );
+        const recentCount = parseInt(rows?.[0]?.cnt || "0");
+        if (recentCount > 200) {
+          return {
+            needsAction: true,
+            summary: `Memory flood detected: ${recentCount} memories in 24h (threshold: 200). Consider pruning.`,
+            priority: "medium",
+            data: { recentCount }
+          };
+        }
+        return { needsAction: false, priority: "low" };
+      } catch {
+        return { needsAction: false, priority: "low" };
+      }
+    }
+  };
+}
+function createUnansweredChatCheck() {
+  return {
+    id: "unanswered_chat",
+    name: "Unanswered Chat Messages",
+    intervalMs: 5 * 6e4,
+    // 5 minutes
+    priority: "high",
+    requiresClockIn: false,
+    consecutiveNoOps: 0,
+    enabled: true,
+    check: async (ctx) => {
+      try {
+        const rows = await ctx.db.query(
+          `SELECT COUNT(*) as cnt FROM agent_sessions 
+           WHERE agent_id = $1 
+           AND status = 'failed'
+           AND metadata::text LIKE '%chat%'
+           AND created_at > NOW() - INTERVAL '1 hour'`,
+          [ctx.agentId]
+        );
+        const failedChats = parseInt(rows?.[0]?.cnt || "0");
+        if (failedChats > 0) {
+          return {
+            needsAction: true,
+            summary: `${failedChats} failed chat session(s) in the last hour. Messages may be unanswered.`,
+            priority: "urgent",
+            data: { failedChats }
+          };
+        }
+        return { needsAction: false, priority: "low" };
+      } catch {
+        return { needsAction: false, priority: "low" };
+      }
+    }
+  };
+}
+function createTaskDeadlineCheck() {
+  return {
+    id: "task_deadlines",
+    name: "Task Deadlines",
+    intervalMs: 60 * 6e4,
+    // 1 hour
+    priority: "medium",
+    requiresClockIn: true,
+    consecutiveNoOps: 0,
+    enabled: true,
+    check: async (ctx) => {
+      try {
+        const rows = await ctx.db.query(
+          `SELECT COUNT(*) as cnt FROM agent_memory 
+           WHERE agent_id = $1 
+           AND category = 'context'
+           AND importance = 'high'
+           AND content LIKE '%deadline%'
+           AND created_at > NOW() - INTERVAL '48 hours'`,
+          [ctx.agentId]
+        );
+        const urgentTasks = parseInt(rows?.[0]?.cnt || "0");
+        if (urgentTasks > 0) {
+          return {
+            needsAction: true,
+            summary: `${urgentTasks} task(s) with approaching deadlines. Agent should review and prioritize.`,
+            priority: "high",
+            data: { urgentTasks }
+          };
+        }
+        return { needsAction: false, priority: "low" };
+      } catch {
+        return { needsAction: false, priority: "low" };
+      }
+    }
+  };
+}
+function createErrorRateCheck() {
+  return {
+    id: "error_rate",
+    name: "Error Rate Monitor",
+    intervalMs: 15 * 6e4,
+    // 15 minutes
+    priority: "high",
+    requiresClockIn: false,
+    // errors can happen anytime
+    consecutiveNoOps: 0,
+    enabled: true,
+    check: async (ctx) => {
+      try {
+        const totalRows = await ctx.db.query(
+          `SELECT COUNT(*) as cnt FROM agent_sessions 
+           WHERE agent_id = $1 AND created_at > NOW() - INTERVAL '1 hour'`,
+          [ctx.agentId]
+        );
+        const failedRows = await ctx.db.query(
+          `SELECT COUNT(*) as cnt FROM agent_sessions 
+           WHERE agent_id = $1 AND status = 'failed' AND created_at > NOW() - INTERVAL '1 hour'`,
+          [ctx.agentId]
+        );
+        const total = parseInt(totalRows?.[0]?.cnt || "0");
+        const failed = parseInt(failedRows?.[0]?.cnt || "0");
+        if (total >= 3 && failed / total > 0.5) {
+          return {
+            needsAction: true,
+            summary: `High error rate: ${failed}/${total} sessions failed in the last hour (${Math.round(failed / total * 100)}%). Possible infrastructure issue.`,
+            priority: "urgent",
+            data: { total, failed, rate: failed / total }
+          };
+        }
+        return { needsAction: false, priority: "low" };
+      } catch {
+        return { needsAction: false, priority: "low" };
+      }
+    }
+  };
+}
+var AgentHeartbeatManager = class {
+  config;
+  settings;
+  checks = /* @__PURE__ */ new Map();
+  tickTimer = null;
+  globalConsecutiveNoOps = 0;
+  lastActionTimestamp = 0;
+  stats = {
+    totalTicks: 0,
+    totalChecksRun: 0,
+    totalActionsTriggered: 0,
+    totalTokensSaved: 0,
+    // estimated tokens NOT spent due to no-op ticks
+    startedAt: Date.now()
+  };
+  constructor(config, settings) {
+    this.config = config;
+    this.settings = { ...DEFAULT_SETTINGS, ...settings };
+    this.registerCheck(createUnreadEmailCheck());
+    this.registerCheck(createUpcomingEventsCheck());
+    this.registerCheck(createStaleSessionsCheck());
+    this.registerCheck(createMemoryHealthCheck());
+    this.registerCheck(createUnansweredChatCheck());
+    this.registerCheck(createTaskDeadlineCheck());
+    this.registerCheck(createErrorRateCheck());
+    if (config.enabledChecks) {
+      for (const [id, enabled] of Object.entries(config.enabledChecks)) {
+        const check = this.checks.get(id);
+        if (check) check.enabled = enabled;
+      }
+    }
+  }
+  registerCheck(check) {
+    this.checks.set(check.id, check);
+  }
+  async start() {
+    if (!this.settings.enabled) {
+      console.log("[heartbeat] Disabled, skipping");
+      return;
+    }
+    console.log(`[heartbeat] Starting with ${this.checks.size} checks, base interval ${this.settings.baseIntervalMs / 1e3}s`);
+    setTimeout(() => this.tick(), 6e4);
+    this.scheduleNextTick();
+  }
+  stop() {
+    if (this.tickTimer) {
+      clearTimeout(this.tickTimer);
+      this.tickTimer = null;
+    }
+    console.log(`[heartbeat] Stopped. Stats: ${this.stats.totalTicks} ticks, ${this.stats.totalChecksRun} checks, ${this.stats.totalActionsTriggered} actions, ~${this.stats.totalTokensSaved} tokens saved`);
+  }
+  getStats() {
+    return {
+      ...this.stats,
+      uptimeMs: Date.now() - this.stats.startedAt,
+      currentIntervalMs: this.calculateInterval(),
+      globalConsecutiveNoOps: this.globalConsecutiveNoOps,
+      checks: Array.from(this.checks.values()).map((c) => ({
+        id: c.id,
+        name: c.name,
+        enabled: c.enabled,
+        lastRunAt: c.lastRunAt,
+        lastActionAt: c.lastActionAt,
+        consecutiveNoOps: c.consecutiveNoOps
+      }))
+    };
+  }
+  // ─── Core Tick Logic ────────────────────────────────
+  async tick() {
+    this.stats.totalTicks++;
+    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 minute = localTime.getMinutes();
+    const dayOfWeek = localTime.getDay();
+    const isWorkHours = this.isWithinWorkHours(hour, minute, dayOfWeek);
+    const isQuietHours = this.isQuietHours(hour);
+    const isClockedIn = this.config.isClockedIn();
+    const ctx = {
+      agentId: this.config.agentId,
+      orgId: this.config.orgId,
+      agentName: this.config.agentName,
+      role: this.config.role,
+      managerEmail: this.config.managerEmail,
+      timezone: tz,
+      db: this.config.db,
+      now,
+      localTime,
+      hour,
+      minute,
+      dayOfWeek,
+      isWorkHours,
+      isClockedIn
+    };
+    const actionableItems = [];
+    for (const check of this.checks.values()) {
+      if (!check.enabled) continue;
+      if (check.requiresClockIn && !isClockedIn) continue;
+      if (isQuietHours && check.priority !== "high") continue;
+      const adaptiveInterval = Math.min(
+        check.intervalMs * (1 + this.settings.dampingFactor * check.consecutiveNoOps),
+        this.settings.maxIntervalMs
+      );
+      const timeSinceLastRun = now.getTime() - (check.lastRunAt || 0);
+      if (timeSinceLastRun < adaptiveInterval) continue;
+      this.stats.totalChecksRun++;
+      check.lastRunAt = now.getTime();
+      try {
+        const result = await check.check(ctx);
+        if (result.needsAction) {
+          actionableItems.push({ check, result });
+          check.consecutiveNoOps = 0;
+          check.lastActionAt = now.getTime();
+        } else {
+          check.consecutiveNoOps++;
+          this.stats.totalTokensSaved += 500;
+        }
+      } catch (err) {
+        console.warn(`[heartbeat] Check ${check.id} error: ${err.message}`);
+        check.consecutiveNoOps++;
+      }
+    }
+    if (actionableItems.length > 0) {
+      this.globalConsecutiveNoOps = 0;
+      this.lastActionTimestamp = now.getTime();
+      this.stats.totalActionsTriggered++;
+      const priorityOrder = { urgent: 0, high: 1, medium: 2, low: 3 };
+      actionableItems.sort((a, b) => priorityOrder[a.result.priority] - priorityOrder[b.result.priority]);
+      const batch = actionableItems.slice(0, this.settings.maxBatchSize);
+      await this.dispatchBatch(batch, ctx);
+    } else {
+      this.globalConsecutiveNoOps++;
+    }
+    this.scheduleNextTick();
+  }
+  /**
+   * Calculate next tick interval using damped oscillator model:
+   *   interval = base * (1 + damping * consecutiveNoOps)
+   * 
+   * With fibonacci-like acceleration:
+   *   After 0 no-ops:  5min  (base)
+   *   After 1 no-op:   7.5min
+   *   After 2 no-ops:  10min
+   *   After 4 no-ops:  15min
+   *   After 8 no-ops:  25min
+   *   After 10 no-ops: 30min (max)
+   * 
+   * Resets to base immediately when action is detected.
+   */
+  calculateInterval() {
+    const base = this.settings.baseIntervalMs;
+    const max = this.settings.maxIntervalMs;
+    const damping = this.settings.dampingFactor;
+    const noOps = this.globalConsecutiveNoOps;
+    return Math.min(base * (1 + damping * noOps), max);
+  }
+  scheduleNextTick() {
+    if (this.tickTimer) clearTimeout(this.tickTimer);
+    const interval = this.calculateInterval();
+    this.tickTimer = setTimeout(() => this.tick(), interval);
+    this.tickTimer.unref();
+  }
+  isWithinWorkHours(hour, minute, dayOfWeek) {
+    const schedule = this.config.schedule;
+    if (!schedule) return true;
+    const isWorkday = schedule.days.includes(dayOfWeek);
+    const timeStr = `${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")}`;
+    const isWithinHours = timeStr >= schedule.start && timeStr < schedule.end;
+    return isWorkday && isWithinHours;
+  }
+  isQuietHours(hour) {
+    const start = this.settings.quietHoursStart;
+    const end = this.settings.quietHoursEnd;
+    if (start === void 0 || end === void 0) return false;
+    if (start > end) {
+      return hour >= start || hour < end;
+    }
+    return hour >= start && hour < end;
+  }
+  /**
+   * Dispatch a batch of actionable items to the agent via one LLM session.
+   * This is the ONLY place tokens are spent.
+   */
+  async dispatchBatch(items, ctx) {
+    if (!this.config.runtime) {
+      console.warn("[heartbeat] No runtime \u2014 cannot dispatch actions");
+      return;
+    }
+    try {
+      const { guardrails } = await import("./routes-PRBWZ4MQ.js");
+      const status = await guardrails.getStatus(ctx.agentId);
+      if (status.paused || status.offDuty) {
+        console.log(`[heartbeat] Skipping action dispatch \u2014 agent is ${status.offDuty ? "off duty" : "paused"}`);
+        return;
+      }
+    } catch {
+    }
+    try {
+      const activeCount = this.config.runtime.getActiveSessionCount?.() ?? 0;
+      if (activeCount > 0) {
+        console.log(`[heartbeat] Deferring action dispatch \u2014 ${activeCount} active session(s) running`);
+        return;
+      }
+    } catch {
+    }
+    const summaries = items.map(
+      (item, i) => `${i + 1}. [${item.result.priority.toUpperCase()}] ${item.check.name}: ${item.result.summary}`
+    ).join("\n");
+    const prompt = `HEARTBEAT ALERT \u2014 The following ${items.length} item(s) need your attention:
+
+${summaries}
+
+For each item, take the appropriate action:
+- For unread emails: Check your inbox with gmail_search and respond to any urgent ones.
+- For upcoming events: Check google_calendar_list for the next 2 hours and prepare.
+- For stale sessions: Review and close any stuck sessions.
+- For unanswered chats: Check Google Chat and respond.
+- For error rate issues: Investigate recent failures and notify your manager if critical.
+- For task deadlines: Review google_tasks_list and prioritize.
+- For memory health: Consider pruning old or low-importance memories.
+
+Be efficient \u2014 handle what you can and note what needs human intervention.
+If something needs your manager's attention, email ${ctx.managerEmail || "your manager"}.`;
+    const systemPrompt = `You are ${ctx.agentName}, a ${ctx.role}. This is an automated heartbeat check \u2014 items flagged as needing attention. Handle them efficiently. Don't create unnecessary work \u2014 only act on what's genuinely important.`;
+    try {
+      const session = await this.config.runtime.spawnSession({
+        agentId: ctx.agentId,
+        message: prompt,
+        systemPrompt
+      });
+      console.log(`[heartbeat] \u2705 Action session ${session.id} dispatched (${items.length} items: ${items.map((i) => i.check.id).join(", ")})`);
+    } catch (err) {
+      console.error(`[heartbeat] Failed to dispatch action: ${err.message}`);
+    }
+  }
+};
+export {
+  AgentHeartbeatManager
+};

package/dist/agent-status-CS5NNYIO.js

@@ -0,0 +1,11 @@
+import {
+  AgentStatusTracker,
+  describeToolActivity,
+  init_agent_status
+} from "./chunk-FQWJMPKW.js";
+import "./chunk-KFQGP6VL.js";
+init_agent_status();
+export {
+  AgentStatusTracker,
+  describeToolActivity
+};