create-walle 0.9.0 → 0.9.3

package/template/wall-e/context/topic-matcher.js

@@ -0,0 +1,79 @@
+'use strict';
+
+/**
+ * Lightweight keyword/regex topic classifier.
+ * No Claude call — pure pattern matching for fast context selection.
+ */
+
+const TOPIC_PATTERNS = {
+  people: {
+    // Names of known people, relationship words
+    keywords: ['who', 'person', 'team', 'report', 'manager', 'colleague', 'relationship', 'trust'],
+    regex: /\b(who\s+is|reports?\s+to|works?\s+with|relationship|team\s+member|direct\s+report|skip.?level)\b/i,
+  },
+  slack: {
+    keywords: ['slack', 'channel', 'message', 'dm', 'thread', 'mention', 'said', 'told', 'wrote', 'posted'],
+    regex: /\b(slack|channel|#\w+|message[sd]?|DM|thread|mention|said|told|wrote|posted|conversation)\b/i,
+  },
+  calendar: {
+    keywords: ['calendar', 'meeting', 'event', 'schedule', 'tomorrow', 'today', 'appointment', '1:1', 'standup'],
+    regex: /\b(calendar|meeting|event|schedule|tomorrow|today|tonight|this\s+week|next\s+week|appointment|1[:-]1|standup|sync|deadline)\b/i,
+  },
+  tasks: {
+    keywords: ['task', 'todo', 'reminder', 'deadline', 'priority', 'action item', 'backlog'],
+    regex: /\b(task|todo|to.?do|reminder|deadline|priority|action\s+item|backlog|sprint|jira|ticket)\b/i,
+  },
+  technical: {
+    keywords: ['code', 'bug', 'deploy', 'api', 'database', 'server', 'git', 'pr', 'review', 'test'],
+    regex: /\b(code|bug|deploy|api|database|server|git|pr|pull\s+request|review|test|build|pipeline|docker|kubernetes|aws|gcp)\b/i,
+  },
+  tools: {
+    keywords: ['tool', 'mcp', 'skill', 'fetch', 'search', 'run', 'execute', 'automation'],
+    regex: /\b(tool|mcp|skill|fetch|search\s+for|run\s+a|execute|automation|script|command|shell)\b/i,
+  },
+  weather: {
+    keywords: ['weather', 'temperature', 'rain', 'snow', 'forecast', 'outside'],
+    regex: /\b(weather|temperature|rain|snow|forecast|outside|humid|cold|hot|warm|sunny|cloudy)\b/i,
+  },
+  personal: {
+    keywords: ['feel', 'think about', 'opinion', 'preference', 'like', 'dislike', 'hobby', 'family'],
+    regex: /\b(feel|opinion|preference|like|dislike|hobby|family|personal|habit|routine|favorite)\b/i,
+  },
+  work: {
+    keywords: ['project', 'okr', 'goal', 'strategy', 'roadmap', 'planning', 'quarterly', 'perf'],
+    regex: /\b(project|okr|goal|strategy|roadmap|planning|quarterly|perf|review|promotion|career|leadership)\b/i,
+  },
+};
+
+/**
+ * Classify a user message into topic tags.
+ * Returns array of matching topic names, e.g. ['people', 'slack'].
+ * Always returns at least ['general'] if no specific match.
+ */
+function classifyTopics(message) {
+  if (!message || typeof message !== 'string') return ['general'];
+
+  const topics = [];
+  const lower = message.toLowerCase();
+
+  for (const [topic, { keywords, regex }] of Object.entries(TOPIC_PATTERNS)) {
+    if (regex.test(message)) {
+      topics.push(topic);
+      continue;
+    }
+    // Fallback: check if any keyword appears as a substring
+    if (keywords.some(kw => lower.includes(kw))) {
+      topics.push(topic);
+    }
+  }
+
+  // Check for people names — if message contains a capitalized word that looks like a name
+  if (!topics.includes('people') && /\b[A-Z][a-z]{2,}\b/.test(message)) {
+    // Could be a person name — add 'people' as a soft match
+    topics.push('people');
+  }
+
+  return topics.length > 0 ? topics : ['general'];
+}
+
+module.exports = { classifyTopics, TOPIC_PATTERNS };

package/template/wall-e/core-tasks.js

@@ -50,4 +50,28 @@ module.exports = [
     skill_config: JSON.stringify({ days_back: 3650, sync_inbox: true }),
     priority: 'normal',
   },
+  {
+    title: 'Proactive Alerts',
+    description: 'Check for time-sensitive items: upcoming meetings, @mentions, approaching deadlines, failed tasks.',
+    type: 'recurring',
+    schedule: 'every 5m',
+    skill: 'proactive-alerts',
+    priority: 'normal',
+  },
+  {
+    title: 'Slack: @walle Mentions',
+    description: 'Poll Slack for @walle mentions from the owner. Creates tasks for assignments, replies in-thread for questions.',
+    type: 'recurring',
+    schedule: 'every 30s',
+    skill: 'slack-mentions',
+    priority: 'normal',
+  },
+  {
+    title: 'Weekly Reflection',
+    description: 'Generate a weekly reflection analyzing patterns, decisions, and insights from the past 7 days.',
+    type: 'recurring',
+    schedule: 'weekly Sunday at 8pm',
+    skill: 'weekly-reflection',
+    priority: 'normal',
+  },
 ];

package/template/wall-e/events/event-bus.js

@@ -0,0 +1,23 @@
+'use strict';
+const EventEmitter = require('events');
+
+class WalleEventBus extends EventEmitter {
+  constructor() {
+    super();
+    this.setMaxListeners(20);
+  }
+
+  emitMessage(channel, text, sender) {
+    this.emit('message', { channel, text, sender, ts: Date.now() });
+  }
+
+  emitHighImportance(memoryId, content) {
+    this.emit('high_importance', { memoryId, content, ts: Date.now() });
+  }
+
+  emitWebhook(source, payload) {
+    this.emit('webhook', { source, payload, ts: Date.now() });
+  }
+}
+
+module.exports = new WalleEventBus();

package/template/wall-e/loops/ingest.js

@@ -1,4 +1,5 @@
 const brain = require('../brain');
+const eventBus = require('../events/event-bus');
 
 async function runOnce(adapters) {
   const checkpoint = brain.getCheckpoint('ingest');
@@ -16,6 +17,9 @@ async function runOnce(adapters) {
           if (!latestTimestamp || mem.timestamp > latestTimestamp) {
             latestTimestamp = mem.timestamp;
           }
+          if (mem.importance >= 0.8 || mem.memory_type === 'message_received') {
+            eventBus.emitHighImportance(result?.id, (mem.content || '').slice(0, 200));
+          }
         }
       }
     } catch (err) {

package/template/wall-e/loops/initiative.js

@@ -0,0 +1,316 @@
+'use strict';
+
+const brain = require('../brain');
+const { buildStateSnapshot, isStateEmpty, formatSnapshot } = require('../context/state-snapshot');
+const { canActAutonomously, getDomainConfidence } = require('../decision/confidence');
+const { buildClientOpts } = require('../extraction/knowledge-extractor');
+const Anthropic = require('@anthropic-ai/sdk');
+const { v4: uuidv4 } = require('uuid');
+
+const COOLDOWN_MS = 30 * 60 * 1000; // 30 minutes between same decisions
+
+/**
+ * Get an Anthropic client configured for Portkey gateway or direct API.
+ * Reuses the same pattern as knowledge-extractor.js
+ */
+function getInitiativeClient() {
+  const opts = buildClientOpts();
+  const isPortkey = opts.defaultHeaders && opts.defaultHeaders['x-portkey-api-key'];
+
+  if (isPortkey) {
+    return {
+      messages: {
+        async create(params, fetchOpts) {
+          const headers = {
+            'content-type': 'application/json',
+            'anthropic-version': '2023-06-01',
+            ...opts.defaultHeaders,
+          };
+          const res = await fetch(opts.baseURL + '/messages', {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(params),
+            signal: fetchOpts?.signal,
+          });
+          if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`${res.status} ${text}`);
+          }
+          return res.json();
+        }
+      }
+    };
+  }
+
+  return new Anthropic(opts);
+}
+
+/**
+ * Build the system prompt for the initiative engine.
+ */
+function buildInitiativePrompt(snapshot, recentDecisions) {
+  const snapshotText = formatSnapshot(snapshot);
+
+  const recentText = recentDecisions.length > 0
+    ? recentDecisions.map(d => `- ${d.decision}: ${d.decision_data || '(no data)'}`).join('\n')
+    : '(none)';
+
+  return `You are WALL-E's initiative engine. You observe the owner's current state and decide whether to take action.
+
+CURRENT STATE:
+${snapshotText}
+
+RECENT DECISIONS (avoid repeating):
+${recentText}
+
+PROACTIVITY RULES:
+- Default to "noop" -- only act when there's clear value
+- Time-sensitive items (calendar in <15min, direct @mention) are highest priority
+- Never send the same notification twice within 30 minutes
+- Consider: is this ACTUALLY useful right now, or just busy work?
+
+Respond in this EXACT format:
+DECISION: noop|notify|create_task|run_skill
+DOMAIN: general|calendar|slack|tasks|knowledge
+REASONING: <1-2 sentences explaining why>
+DATA: <JSON with details if not noop>`;
+}
+
+/**
+ * Parse Claude's structured decision output.
+ */
+function parseDecision(text) {
+  const result = {
+    decision: 'noop',
+    domain: 'general',
+    reasoning: '',
+    data: null,
+  };
+
+  const decisionMatch = text.match(/^DECISION:\s*(\S+)/m);
+  if (decisionMatch) {
+    const d = decisionMatch[1].toLowerCase().trim();
+    if (['noop', 'notify', 'create_task', 'run_skill'].includes(d)) {
+      result.decision = d;
+    }
+  }
+
+  const domainMatch = text.match(/^DOMAIN:\s*(\S+)/m);
+  if (domainMatch) {
+    result.domain = domainMatch[1].toLowerCase().trim();
+  }
+
+  const reasoningMatch = text.match(/^REASONING:\s*(.+)/m);
+  if (reasoningMatch) {
+    result.reasoning = reasoningMatch[1].trim();
+  }
+
+  const dataMatch = text.match(/^DATA:\s*(.+)/ms);
+  if (dataMatch) {
+    const raw = dataMatch[1].trim();
+    if (raw && raw !== 'null' && raw !== 'none' && raw !== 'N/A') {
+      try {
+        // Try to extract JSON from the data line (may span multiple lines)
+        const jsonMatch = raw.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+          result.data = JSON.parse(jsonMatch[0]);
+        } else {
+          // No JSON object found, store as raw string
+          result.data = { raw: raw.slice(0, 500) };
+        }
+      } catch (_) {
+        // If JSON parse fails, store as string
+        result.data = { raw: raw.slice(0, 500) };
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Get the autonomy tier for a domain.
+ */
+function getTier(domain) {
+  try {
+    const dc = getDomainConfidence(domain);
+    return dc.current_tier;
+  } catch (_) {
+    return 1;
+  }
+}
+
+/**
+ * Log an initiative decision to the database.
+ */
+function logInitiative(trigger, snapshot, reasoning, decision, decisionData, autonomyTier) {
+  return brain.insertInitiativeLog({
+    trigger,
+    state_snapshot: JSON.stringify(snapshot).slice(0, 5000),
+    reasoning: reasoning ? reasoning.slice(0, 2000) : null,
+    decision,
+    decision_data: decisionData ? JSON.stringify(decisionData).slice(0, 5000) : null,
+    autonomy_tier: autonomyTier || 1,
+  });
+}
+
+/**
+ * Execute a decision based on its type.
+ */
+async function executeDecision(decision, snapshot) {
+  switch (decision.decision) {
+    case 'noop':
+      return;
+
+    case 'notify': {
+      // Send notification via chat message log (visible in CTM dashboard)
+      const msg = decision.data?.message || decision.reasoning || 'Initiative notification';
+      brain.insertChatMessage({
+        role: 'assistant',
+        content: `[Initiative] ${msg}`,
+        channel: 'initiative',
+        session_id: 'initiative-' + new Date().toISOString().slice(0, 10),
+      });
+      // Also send macOS notification for visibility
+      try {
+        const { sendNotification } = require('../tools/local-tools');
+        await sendNotification('WALL-E', msg.slice(0, 200));
+      } catch {}
+      return;
+    }
+
+    case 'create_task': {
+      const taskData = decision.data || {};
+      brain.insertTask({
+        title: taskData.title || decision.reasoning || 'Auto-created task',
+        description: taskData.description || decision.reasoning,
+        priority: taskData.priority || 'normal',
+        type: 'once',
+        due_at: taskData.due_at || null,
+      });
+      return;
+    }
+
+    case 'run_skill': {
+      // Attempt to run a skill by name
+      const skillName = decision.data?.skill;
+      if (!skillName) return;
+      try {
+        const { executeSkill } = require('../skills/skill-executor');
+        const skill = brain.getSkillByName(skillName);
+        if (skill && skill.enabled) {
+          await executeSkill(skill);
+        }
+      } catch (err) {
+        console.error('[wall-e] Initiative skill execution failed:', err.message);
+      }
+      return;
+    }
+
+    default:
+      return;
+  }
+}
+
+/**
+ * Check cooldown: is the same decision type + domain already in recent logs?
+ */
+function isOnCooldown(decision, recentDecisions) {
+  if (decision.decision === 'noop') return false;
+  return recentDecisions.some(d => {
+    if (d.decision !== decision.decision) return false;
+    // For notify, only cooldown if the message is the same
+    if (decision.decision === 'notify') {
+      try {
+        const prev = JSON.parse(d.decision_data);
+        return prev?.message && decision.data?.message &&
+               prev.message === decision.data.message;
+      } catch (_) {
+        return true; // Can't parse — assume duplicate
+      }
+    }
+    // For other decision types, same type = on cooldown
+    return true;
+  });
+}
+
+/**
+ * Main initiative loop function. Called on an interval from agent.js
+ */
+async function runInitiativeLoop(opts = {}) {
+  const snapshot = buildStateSnapshot();
+
+  // Check if there's anything worth reasoning about
+  if (isStateEmpty(snapshot)) {
+    return { decision: 'noop', reasoning: 'Nothing to evaluate' };
+  }
+
+  // Check cooldown -- avoid repeating recent decisions
+  const db = brain.getDb();
+  const recentDecisions = db.prepare(
+    "SELECT decision, decision_data FROM initiative_log WHERE created_at > datetime('now', '-30 minutes') ORDER BY created_at DESC LIMIT 10"
+  ).all();
+
+  // Call Claude with a focused prompt
+  const client = opts.client || getInitiativeClient();
+  const model = opts.model || process.env.WALLE_MODEL || 'claude-haiku-4-5-20251001';
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 30000);
+
+  let decision;
+  try {
+    const response = await client.messages.create({
+      model,
+      max_tokens: 1024,
+      system: buildInitiativePrompt(snapshot, recentDecisions),
+      messages: [{ role: 'user', content: 'Evaluate current state and decide your next action.' }],
+    }, { signal: controller.signal });
+
+    const text = response.content
+      .filter(b => b.type === 'text')
+      .map(b => b.text)
+      .join('');
+
+    decision = parseDecision(text);
+  } finally {
+    clearTimeout(timeout);
+  }
+
+  // Gate by autonomy tier
+  const domain = decision.domain || 'general';
+  const isHighRisk = decision.decision === 'notify';
+
+  if (decision.decision !== 'noop') {
+    // Check cooldown
+    if (isOnCooldown(decision, recentDecisions)) {
+      logInitiative(opts.trigger || 'scheduled', snapshot, decision.reasoning, 'cooldown', decision.data, getTier(domain));
+      return { decision: 'cooldown', reasoning: decision.reasoning };
+    }
+
+    // Proactivity model: start conservative, graduate
+    if (!canActAutonomously(domain, isHighRisk)) {
+      // Below tier threshold -- log observation but don't act
+      logInitiative(opts.trigger || 'scheduled', snapshot, decision.reasoning, 'observed', decision.data, getTier(domain));
+      return { decision: 'observed', reasoning: decision.reasoning, original: decision.decision };
+    }
+  }
+
+  // Execute the decision
+  if (decision.decision !== 'noop') {
+    await executeDecision(decision, snapshot);
+  }
+  logInitiative(opts.trigger || 'scheduled', snapshot, decision.reasoning, decision.decision, decision.data, getTier(domain));
+
+  return decision;
+}
+
+module.exports = {
+  runInitiativeLoop,
+  parseDecision,
+  buildInitiativePrompt,
+  isOnCooldown,
+  getInitiativeClient,
+  // Exported for testing
+  _test: { logInitiative, executeDecision, getTier },
+};

package/template/wall-e/loops/tasks.js

@@ -115,8 +115,8 @@ async function runDueTasks() {
         console.error('[tasks] Briefing item consolidation failed:', e.message);
       }
 
-      // Notify (skip frequent recurring)
-      if (task.type !== 'recurring' || !task.schedule?.match(/every\s+\d+\s*m/i)) {
+      // Notify (skip frequent recurring — minutes or seconds intervals)
+      if (task.type !== 'recurring' || !task.schedule?.match(/every\s+\d+\s*[ms]/i)) {
         try {
           const { sendNotification } = require('../tools/local-tools');
           await sendNotification('WALL-E Task', task.title + ' — done');
@@ -326,6 +326,12 @@ function executeScript(taskId, script, checkpoint, extraEnv) {
 // ── Chat execution with log streaming ──
 
 async function executeChat(taskId, task) {
+  // Use multi-turn for complex tasks
+  if (task.execution === 'multi-turn') {
+    return executeMultiTurnChat(taskId, task);
+  }
+
+  // Single-turn (existing behavior)
   const chatModule = require('../chat');
   const prompt = buildTaskPrompt(task);
 
@@ -344,6 +350,50 @@ async function executeChat(taskId, task) {
   return result.reply || '';
 }
 
+/**
+ * Execute a task using multiple chat turns, maintaining session state.
+ * Each turn can use tools, and progress is checkpointed between turns.
+ */
+async function executeMultiTurnChat(taskId, task) {
+  const chatModule = require('../chat');
+  const sessionId = `task-${task.id}`;
+  const MAX_TASK_TURNS = 5;
+  let lastReply = '';
+
+  for (let turn = 0; turn < MAX_TASK_TURNS; turn++) {
+    const prompt = turn === 0
+      ? buildTaskPrompt(task)
+      : 'Continue working on this task. Review your progress so far and take the next step. If you are done, include [TASK COMPLETE] in your response.';
+
+    appendLog(taskId, `Multi-turn ${turn + 1}/${MAX_TASK_TURNS}...`);
+
+    const result = await chatModule.chat(prompt, {
+      channel: 'task',
+      session_id: sessionId,
+      onProgress: (event) => {
+        if (event.type === 'tool_call') appendLog(taskId, event.summary);
+        else if (event.type === 'tool_done') appendLog(taskId, `Done: ${event.summary}`);
+      },
+    });
+
+    lastReply = result.reply || '';
+    appendLog(taskId, `Turn ${turn + 1} result: ${lastReply.slice(0, 200)}`);
+
+    // Check if task declared itself complete
+    if (lastReply.includes('[TASK COMPLETE]') || lastReply.includes('[DONE]')) {
+      appendLog(taskId, 'Task self-declared complete');
+      break;
+    }
+
+    // Checkpoint between turns
+    brain.updateTask(taskId, {
+      checkpoint: JSON.stringify({ turn: turn + 1, partial: lastReply.slice(0, 2000) }),
+    });
+  }
+
+  return lastReply;
+}
+
 function buildTaskPrompt(task) {
   let prompt = `[TASK] ${task.title}`;
   if (task.description) prompt += `\n\n${task.description}`;
@@ -394,11 +444,11 @@ function computeNextDue(schedule) {
   if (schedule === 'daily') return new Date(now.getTime() + 86400000).toISOString();
   if (schedule === 'weekly') return new Date(now.getTime() + 604800000).toISOString();
 
-  const everyMatch = schedule.match(/^every\s+(\d+)\s*(m|h|d)$/i);
+  const everyMatch = schedule.match(/^every\s+(\d+)\s*(s|m|h|d)$/i);
   if (everyMatch) {
     const n = parseInt(everyMatch[1]);
     const unit = everyMatch[2].toLowerCase();
-    const ms = unit === 'h' ? n * 3600000 : unit === 'm' ? n * 60000 : n * 86400000;
+    const ms = unit === 's' ? n * 1000 : unit === 'h' ? n * 3600000 : unit === 'm' ? n * 60000 : n * 86400000;
     return new Date(now.getTime() + ms).toISOString();
   }
 
@@ -484,4 +534,4 @@ function consolidateBriefingItems(task, resultText, timestamp) {
   }
 }
 
-module.exports = { runDueTasks, runTaskById, recoverInterruptedTasks, buildTaskPrompt, computeNextDue, getTaskLogs, clearTaskLogs, stopTask, executeSkill, consolidateBriefingItems, taskLogs };
+module.exports = { runDueTasks, runTaskById, recoverInterruptedTasks, buildTaskPrompt, computeNextDue, getTaskLogs, clearTaskLogs, stopTask, executeSkill, executeMultiTurnChat, consolidateBriefingItems, taskLogs };

package/template/wall-e/skills/_bundled/email-sync/run.js

@@ -44,8 +44,10 @@ function readEmails() {
   const jxaArgs = ['-l', 'JavaScript', JXA_SCRIPT, '--days-back', String(daysBack)];
   if (syncInbox) jxaArgs.push('--inbox');
 
+  // Scale timeout with daysBack: 5 min for ≤7 days, up to 2 hours for a full year
+  const timeoutMs = daysBack <= 7 ? 300_000 : Math.min(daysBack * 20_000, 7_200_000);
   const result = execFileSync('osascript', jxaArgs, {
-    timeout: 300_000, // 5 min for content fetching
+    timeout: timeoutMs,
     maxBuffer: 50 * 1024 * 1024,
   });
 

package/template/wall-e/skills/_bundled/morning-briefing/run.js

@@ -71,6 +71,47 @@ async function main() {
   }
   sections.push(calSection);
 
+  // ── 1b. Initiative Activity (last 24h) ──
+  let initiativeSection = '';
+  try {
+    const yesterday = new Date(now.getTime() - 24 * 3600000).toISOString();
+    const initiatives = db.prepare(`
+      SELECT decision, reasoning, decision_data, created_at
+      FROM initiative_log
+      WHERE decision != 'noop' AND decision != 'cooldown' AND created_at > ?
+      ORDER BY created_at DESC LIMIT 10
+    `).all(yesterday);
+
+    if (initiatives.length > 0) {
+      initiativeSection = '## WALL-E Activity (last 24h)\n\n';
+      for (const init of initiatives) {
+        const time = formatTime(init.created_at);
+        const action = init.decision === 'observed' ? 'Observed'
+          : init.decision === 'notify' ? 'Notified'
+          : init.decision === 'create_task' ? 'Created task'
+          : init.decision === 'run_skill' ? 'Ran skill'
+          : init.decision;
+        initiativeSection += `- ${time} -- ${action}: ${init.reasoning || '(no reason)'}\n`;
+      }
+      initiativeSection += '\n';
+    }
+  } catch {}
+  if (initiativeSection) sections.push(initiativeSection);
+
+  // ── 1c. Weekly Reflection (Mondays only) ──
+  if (now.getDay() === 1) { // Monday
+    try {
+      const lastWeekly = db.prepare(`
+        SELECT summary FROM daily_summaries
+        WHERE date > datetime('now', '-3 days') AND summary LIKE '%Weekly%'
+        ORDER BY date DESC LIMIT 1
+      `).get();
+      if (lastWeekly?.summary) {
+        sections.push(`## Last Week's Reflection\n\n${lastWeekly.summary.slice(0, 500)}\n`);
+      }
+    } catch {}
+  }
+
   // ── 2. Overnight Slack Activity ──
   const hoursBack = 18;
   const cutoff = new Date(now.getTime() - hoursBack * 3600000).toISOString();

package/template/wall-e/skills/_bundled/proactive-alerts/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: proactive-alerts
+description: >
+  Detect and surface time-sensitive items: upcoming meetings, direct @mentions,
+  approaching deadlines, failed tasks. Routes alerts through the initiative engine.
+version: 1.0.0
+author: wall-e
+execution: script
+entry: run.js
+trigger:
+  type: interval
+  schedule: "every 5m"
+tags: [alerts, proactive, mentions, calendar, deadlines]
+permissions:
+  - brain:read
+  - calendar:read
+---
+# Proactive Alerts
+
+Checks for time-sensitive items and outputs structured alert data.