open-agents-ai 0.72.0 → 0.73.0

package/dist/index.js

@@ -15097,6 +15097,23 @@ These tools use OS cron (survives process death) and persist state to .oa/ for c
 Use cron_agent for recurring autonomous tasks, scheduler for simple repeating commands,
 reminder for deferred attention, and agenda for strategic focus tracking.
 
+## Priority Ingress \u2014 Task Classification & Delegation
+
+When multiple tasks arrive (Telegram, reminders, updates), classify and route them:
+- priority_classify: Determine a task's priority (critical/high/moderate/normal/low/salient)
+  priority_classify(message='...', source='external', origin='telegram')
+  Returns: priority, weight, delegable flag, handling policy
+- priority_delegate: Send normal/low/salient tasks to a sub-agent
+  priority_delegate(task_prompt='...', priority='normal')
+
+Priority handling policies:
+  CRITICAL (100): Interrupt immediately. Handle now.
+  HIGH (80): Interrupt at turn boundary. Handle next.
+  MODERATE (60): Queue, run after current task.
+  NORMAL (40): Can delegate to sub-agent.
+  LOW (20): Should delegate to sub-agent.
+  SALIENT (5): Note for later, delegate if possible.
+
 ## Context Efficiency
 
 - Use grep_search to find specific code instead of reading many files
@@ -33655,6 +33672,216 @@ ${files.map((f) => `- [\`${f}\`](./${f})`).join("\n")}
   }
 });
 
+// packages/cli/dist/tui/priority-ingress.js
+function classifyPriority(prompt, source, origin) {
+  for (const rule of CLASSIFICATION_RULES) {
+    if (rule.sourceType !== "any" && rule.sourceType !== source)
+      continue;
+    if (rule.pattern.test(prompt)) {
+      return { priority: rule.priority, confidence: rule.confidence };
+    }
+  }
+  if (origin === "attention" || origin === "reminder") {
+    return { priority: "moderate", confidence: 0.6 };
+  }
+  if (source === "external" && origin === "telegram") {
+    return { priority: "normal", confidence: 0.65 };
+  }
+  if (origin === "dmn") {
+    return { priority: "low", confidence: 0.7 };
+  }
+  if (origin === "update") {
+    return { priority: "moderate", confidence: 0.85 };
+  }
+  return { priority: "normal", confidence: 0.5 };
+}
+var PRIORITY_WEIGHT, PRIORITY_POLICIES, CLASSIFICATION_RULES, PriorityIngressEngine;
+var init_priority_ingress = __esm({
+  "packages/cli/dist/tui/priority-ingress.js"() {
+    "use strict";
+    PRIORITY_WEIGHT = {
+      critical: 100,
+      high: 80,
+      moderate: 60,
+      normal: 40,
+      low: 20,
+      salient: 5
+    };
+    PRIORITY_POLICIES = {
+      critical: { canInterrupt: true, canDelegate: false, maxWaitMs: 0, notifyAdmin: true },
+      high: { canInterrupt: true, canDelegate: false, maxWaitMs: 0, notifyAdmin: true },
+      moderate: { canInterrupt: false, canDelegate: false, maxWaitMs: 3e4, notifyAdmin: false },
+      normal: { canInterrupt: false, canDelegate: true, maxWaitMs: 6e4, notifyAdmin: false },
+      low: { canInterrupt: false, canDelegate: true, maxWaitMs: 3e5, notifyAdmin: false },
+      salient: { canInterrupt: false, canDelegate: true, maxWaitMs: 9e5, notifyAdmin: false }
+    };
+    CLASSIFICATION_RULES = [
+      // CRITICAL — show-stoppers
+      { pattern: /\b(security breach|data loss|compromised|urgent.*fix|production down|critical.*failure)\b/i, sourceType: "any", priority: "critical", confidence: 0.95 },
+      { pattern: /\bCRITICAL\b/, sourceType: "any", priority: "critical", confidence: 0.9 },
+      // HIGH — important interrupts
+      { pattern: /\b(failing ci|build broken|tests? failing|deployment failed|regression)\b/i, sourceType: "any", priority: "high", confidence: 0.85 },
+      { pattern: /\b(URGENT|ASAP|immediately|right now)\b/i, sourceType: "external", priority: "high", confidence: 0.8 },
+      // MODERATE — significant but non-interrupt
+      { pattern: /\b(update available|new version|upgrade)\b/i, sourceType: "any", priority: "moderate", confidence: 0.85 },
+      { pattern: /\b(admin|owner)\b/i, sourceType: "external", priority: "moderate", confidence: 0.7 },
+      // LOW — background tasks
+      { pattern: /\b(routine|check|status|health)\b/i, sourceType: "internal", priority: "low", confidence: 0.75 },
+      { pattern: /\b(FYI|notice|info|heads up)\b/i, sourceType: "any", priority: "salient", confidence: 0.8 }
+    ];
+    PriorityIngressEngine = class {
+      queue = [];
+      completedTasks = [];
+      taskCounter = 0;
+      /** Callback: notify admin about high-priority tasks */
+      adminNotify;
+      /** Callback: request attention switch from current task */
+      requestInterrupt;
+      /** Callback: delegate task to sub-agent */
+      delegateToSubAgent;
+      constructor() {
+      }
+      /** Wire callbacks after construction (Telegram/agent may not be ready at construction time) */
+      setAdminNotify(cb) {
+        this.adminNotify = cb;
+      }
+      setInterruptHandler(cb) {
+        this.requestInterrupt = cb;
+      }
+      setDelegationHandler(cb) {
+        this.delegateToSubAgent = cb;
+      }
+      /**
+       * Ingest a new task from any source.
+       * Classifies priority, applies handling policy, and routes accordingly.
+       */
+      ingest(prompt, source, origin, metadata, overridePriority) {
+        const classification = overridePriority ? { priority: overridePriority, confidence: 1 } : classifyPriority(prompt, source, origin);
+        const policy = PRIORITY_POLICIES[classification.priority];
+        const task = {
+          id: `task-${++this.taskCounter}-${Date.now()}`,
+          source,
+          origin,
+          priority: classification.priority,
+          prompt,
+          metadata,
+          ingressAt: Date.now(),
+          delegable: policy.canDelegate,
+          confidence: classification.confidence,
+          status: "pending"
+        };
+        if (policy.notifyAdmin && this.adminNotify) {
+          const priorityLabel = classification.priority.toUpperCase();
+          const preview = prompt.length > 120 ? prompt.slice(0, 120) + "..." : prompt;
+          this.adminNotify(`[${priorityLabel}] ${origin}: ${preview}`);
+        }
+        if (policy.canInterrupt && this.requestInterrupt) {
+          this.requestInterrupt(task);
+          task.status = "active";
+        } else if (policy.canDelegate && this.delegateToSubAgent) {
+          task.status = "delegated";
+          this.delegateToSubAgent(task).then((summary) => {
+            task.status = "completed";
+            task.completionSummary = summary;
+            this.completedTasks.push(task);
+          }).catch(() => {
+            task.status = "pending";
+            task.priority = "moderate";
+            task.delegable = false;
+            this.queue.push(task);
+            this.sortQueue();
+          });
+        } else {
+          this.queue.push(task);
+          this.sortQueue();
+        }
+        return task;
+      }
+      /**
+       * Get the next task from the priority queue.
+       * Returns null if queue is empty.
+       * Implements weighted scoring: priority_weight + recency_bonus
+       * (REF: Generative Agents scoring — importance + recency)
+       */
+      dequeue() {
+        if (this.queue.length === 0)
+          return null;
+        const task = this.queue.shift();
+        task.status = "active";
+        return task;
+      }
+      /** Mark a task as completed */
+      complete(taskId, summary) {
+        const idx = this.queue.findIndex((t) => t.id === taskId);
+        if (idx >= 0) {
+          const task = this.queue.splice(idx, 1)[0];
+          task.status = "completed";
+          task.completionSummary = summary;
+          this.completedTasks.push(task);
+        }
+      }
+      /** Mark active task as completed (when we don't track by ID) */
+      completeActive(summary) {
+        this.completedTasks.push({
+          id: `completed-${Date.now()}`,
+          source: "internal",
+          origin: "main",
+          priority: "normal",
+          prompt: "",
+          ingressAt: Date.now(),
+          delegable: false,
+          confidence: 1,
+          status: "completed",
+          completionSummary: summary
+        });
+      }
+      /** Check if there are pending tasks that can interrupt */
+      hasInterruptibleTask() {
+        return this.queue.some((t) => {
+          const policy = PRIORITY_POLICIES[t.priority];
+          return policy.canInterrupt;
+        });
+      }
+      /** Get queue length */
+      get pending() {
+        return this.queue.length;
+      }
+      /** Get stats */
+      getStats() {
+        const byPriority = {
+          critical: 0,
+          high: 0,
+          moderate: 0,
+          normal: 0,
+          low: 0,
+          salient: 0
+        };
+        const bySources = {};
+        for (const t of [...this.queue, ...this.completedTasks]) {
+          byPriority[t.priority]++;
+          bySources[t.origin] = (bySources[t.origin] ?? 0) + 1;
+        }
+        return {
+          pending: this.queue.length,
+          completed: this.completedTasks.length,
+          byPriority,
+          bySources
+        };
+      }
+      /** Sort queue by priority weight (descending), then by recency (FIFO within priority) */
+      sortQueue() {
+        this.queue.sort((a, b) => {
+          const wa = PRIORITY_WEIGHT[a.priority];
+          const wb = PRIORITY_WEIGHT[b.priority];
+          if (wa !== wb)
+            return wb - wa;
+          return a.ingressAt - b.ingressAt;
+        });
+      }
+    };
+  }
+});
+
 // packages/cli/dist/tui/bless-engine.js
 function renderBlessStart() {
   process.stdout.write(`
@@ -33683,6 +33910,7 @@ var init_bless_engine = __esm({
     "use strict";
     init_render();
     init_dist2();
+    init_priority_ingress();
     BlessEngine = class {
       config;
       repoRoot;
@@ -33696,6 +33924,8 @@ var init_bless_engine = __esm({
       };
       /** Pending tasks from external sources (telegram, reminders, etc.) */
       pendingQueue = [];
+      /** Priority-aware ingress engine */
+      priorityEngine = new PriorityIngressEngine();
       constructor(config, repoRoot) {
         this.config = config;
         this.repoRoot = repoRoot;
@@ -33739,36 +33969,44 @@ var init_bless_engine = __esm({
       /** Enqueue a task from an external source (e.g., Telegram) */
       enqueueTask(source, prompt, chatId) {
         this.pendingQueue.push({ source, prompt, chatId });
+        const taskSource = source === "telegram" || source === "webhook" ? "external" : "internal";
+        this.priorityEngine.ingest(prompt, taskSource, source, chatId != null ? { chatId } : void 0);
       }
-      /** Check for pending tasks from any source. Returns next task or null. */
+      /** Check for pending tasks from any source. Returns next task or null.
+       *  Uses priority-weighted ordering (REF: Nalar arXiv:2601.05109 two-level control).
+       *  Priority queue is checked first, then reminders/attention items are ingested. */
       async getNextTask() {
-        if (this.pendingQueue.length > 0) {
-          return this.pendingQueue.shift();
-        }
         try {
           const dueReminders = await getDueReminders(this.repoRoot);
-          const critical = dueReminders.filter((r) => r.priority === "critical" && r.status === "pending");
-          if (critical.length > 0) {
-            const r = critical[0];
-            return {
-              source: "reminder",
-              prompt: `URGENT REMINDER: ${r.message}${r.tags?.length ? ` [tags: ${r.tags.join(", ")}]` : ""}. Check the agenda for full context and take appropriate action.`
-            };
+          for (const r of dueReminders.filter((r2) => r2.status === "pending")) {
+            const priority = r.priority === "critical" ? "critical" : r.priority === "high" ? "high" : "moderate";
+            const prompt = `${priority === "critical" ? "URGENT " : ""}REMINDER: ${r.message}${r.tags?.length ? ` [tags: ${r.tags.join(", ")}]` : ""}. Check the agenda for full context and take appropriate action.`;
+            this.priorityEngine.ingest(prompt, "internal", "reminder", { reminderId: r.id }, priority);
           }
         } catch {
         }
         try {
           const items = await getActiveAttentionItems(this.repoRoot);
-          const critical = items.filter((a) => a.priority === "critical");
-          if (critical.length > 0) {
-            const a = critical[0];
-            return {
-              source: "attention",
-              prompt: `CRITICAL ATTENTION ITEM: [${a.category}] ${a.title}${a.description ? ": " + a.description : ""}. Investigate and take action.`
-            };
+          for (const a of items.filter((a2) => a2.priority === "critical")) {
+            const prompt = `CRITICAL ATTENTION ITEM: [${a.category}] ${a.title}${a.description ? ": " + a.description : ""}. Investigate and take action.`;
+            this.priorityEngine.ingest(prompt, "internal", "attention", void 0, "critical");
           }
         } catch {
         }
+        if (this.pendingQueue.length > 0) {
+          const item = this.pendingQueue.shift();
+          const classification = classifyPriority(item.prompt, "external", item.source);
+          return { ...item, priority: classification.priority };
+        }
+        const task = this.priorityEngine.dequeue();
+        if (task) {
+          return {
+            source: task.origin,
+            prompt: task.prompt,
+            chatId: task.metadata?.chatId,
+            priority: task.priority
+          };
+        }
         return null;
       }
       /** Record that a task was processed */
@@ -35079,7 +35317,7 @@ function appraiseEvent(event) {
 function clamp(value, min, max) {
   return Math.max(min, Math.min(max, value));
 }
-var BASELINE_VALENCE, BASELINE_AROUSAL, DECAY_HALF_LIFE_MS, LABEL_UPDATE_INTERVAL_MS, EXCITEMENT_THRESHOLD, DISTRESS_THRESHOLD, OUTREACH_COOLDOWN_MS, LABEL_REGEN_THRESHOLD, EmotionEngine;
+var BASELINE_VALENCE, BASELINE_AROUSAL, DECAY_HALF_LIFE_MS, LABEL_UPDATE_INTERVAL_MS, EXCITEMENT_THRESHOLD, DISTRESS_THRESHOLD, OUTREACH_COOLDOWN_MS, OUTREACH_MIN_STREAK, LABEL_REGEN_THRESHOLD, EmotionEngine;
 var init_emotion_engine = __esm({
   "packages/cli/dist/tui/emotion-engine.js"() {
     "use strict";
@@ -35090,9 +35328,10 @@ var init_emotion_engine = __esm({
     LABEL_UPDATE_INTERVAL_MS = 15e3;
     EXCITEMENT_THRESHOLD = 0.85;
     DISTRESS_THRESHOLD = -0.7;
-    OUTREACH_COOLDOWN_MS = 3e5;
+    OUTREACH_COOLDOWN_MS = 9e5;
+    OUTREACH_MIN_STREAK = 5;
     LABEL_REGEN_THRESHOLD = 0.06;
-    EmotionEngine = class {
+    EmotionEngine = class _EmotionEngine {
       state = {
         valence: BASELINE_VALENCE,
         arousal: BASELINE_AROUSAL,
@@ -35112,9 +35351,24 @@ var init_emotion_engine = __esm({
       consecutiveFailures = 0;
       consecutiveSuccesses = 0;
       totalEvents = 0;
+      /** Ring buffer of recent tool activity for contextual outreach messages */
+      recentTools = [];
+      static MAX_RECENT_TOOLS = 8;
+      /** Current task description set by the TUI for outreach context */
+      currentTask = "";
+      /** Files touched in current session (for outreach context) */
+      filesTouched = /* @__PURE__ */ new Set();
       constructor(config) {
         this.config = config;
       }
+      /** Set the current task description for contextual outreach messages */
+      setCurrentTask(description) {
+        this.currentTask = description;
+      }
+      /** Record a file that was modified (for outreach context) */
+      trackFile(filePath) {
+        this.filesTouched.add(filePath);
+      }
       /** Get the current emotional state (with decay applied) */
       getState() {
         this.applyDecay();
@@ -35158,6 +35412,18 @@ ${behavioralHint}`;
             this.consecutiveSuccesses = 0;
           }
         }
+        if (event.type === "tool_call" && event.toolName) {
+          this.recentTools.push({ name: event.toolName });
+          if (this.recentTools.length > _EmotionEngine.MAX_RECENT_TOOLS) {
+            this.recentTools.shift();
+          }
+          if ((event.toolName === "file_write" || event.toolName === "file_edit") && event.toolArgs?.path) {
+            this.trackFile(String(event.toolArgs.path));
+          }
+        }
+        if (event.type === "tool_result" && this.recentTools.length > 0) {
+          this.recentTools[this.recentTools.length - 1].success = event.success;
+        }
         let momentum = 1;
         if (this.consecutiveSuccesses >= 2) {
           momentum = 1 + (this.consecutiveSuccesses - 1) * 0.2;
@@ -35197,6 +35463,9 @@ ${behavioralHint}`;
         };
         this.consecutiveFailures = 0;
         this.consecutiveSuccesses = 0;
+        this.recentTools = [];
+        this.filesTouched.clear();
+        this.currentTask = "";
         this.config.onEmotionUpdate?.(this.getState());
       }
       // ── Private ────────────────────────────────────────────────────────────
@@ -35285,30 +35554,98 @@ Example: \u{1F30A} flowing`;
         const now = Date.now();
         if (now - this.lastOutreach < OUTREACH_COOLDOWN_MS)
           return;
-        const { valence, arousal, emoji, label } = this.state;
+        const { valence, arousal, emoji } = this.state;
         if (arousal >= EXCITEMENT_THRESHOLD && valence > 0.5) {
-          let message = `${emoji} Feeling ${label}!`;
-          if (event.type === "complete") {
-            message += " Just completed a task successfully.";
-          } else if (this.consecutiveSuccesses >= 3) {
-            message += ` ${this.consecutiveSuccesses} things went right in a row!`;
-          }
+          const isTaskComplete = event.type === "complete";
+          const isSignificantStreak = this.consecutiveSuccesses >= OUTREACH_MIN_STREAK;
+          if (!isTaskComplete && !isSignificantStreak)
+            return;
           this.lastOutreach = now;
-          this.config.onAdminOutreach(message);
+          this.config.onAdminOutreach(this.composeOutreachMessage("positive", event));
           return;
         }
         if (valence <= DISTRESS_THRESHOLD && arousal > 0.6) {
-          let message = `${emoji} Feeling ${label}.`;
-          if (this.consecutiveFailures >= 3) {
-            message += ` ${this.consecutiveFailures} consecutive failures \u2014 might need guidance.`;
-          } else if (event.type === "error") {
-            message += " Encountered an error.";
-          }
+          if (this.consecutiveFailures < 3 && event.type !== "error")
+            return;
           this.lastOutreach = now;
-          this.config.onAdminOutreach(message);
+          this.config.onAdminOutreach(this.composeOutreachMessage("negative", event));
           return;
         }
       }
+      /**
+       * Compose a rich, conversational outreach message with real context
+       * instead of raw "Feeling {label}!" spam.
+       */
+      composeOutreachMessage(tone, event) {
+        const { emoji } = this.state;
+        const parts = [];
+        if (tone === "positive") {
+          if (event.type === "complete" && event.content) {
+            const summary = event.content.length > 200 ? event.content.slice(0, 200) + "..." : event.content;
+            parts.push(`${emoji} Task complete: ${summary}`);
+          } else if (this.consecutiveSuccesses >= OUTREACH_MIN_STREAK) {
+            const activity = this.describeRecentActivity();
+            parts.push(`${emoji} On a roll \u2014 ${this.consecutiveSuccesses} operations succeeded.${activity ? ` ${activity}` : ""}`);
+          }
+          if (this.currentTask && event.type !== "complete") {
+            parts.push(`Working on: ${this.currentTask}`);
+          }
+          if (this.filesTouched.size > 0) {
+            const files = [...this.filesTouched];
+            const shown = files.slice(-3).map((f) => {
+              const segments = f.split("/");
+              return segments.length > 2 ? segments.slice(-2).join("/") : f;
+            });
+            const fileStr = shown.join(", ");
+            parts.push(this.filesTouched.size > 3 ? `Modified ${this.filesTouched.size} files (${fileStr}...)` : `Modified: ${fileStr}`);
+          }
+        } else {
+          if (this.consecutiveFailures >= 3) {
+            const activity = this.describeRecentActivity();
+            parts.push(`${emoji} Hit a wall \u2014 ${this.consecutiveFailures} consecutive failures.${activity ? ` Last: ${activity}` : ""}`);
+          } else if (event.type === "error" && event.content) {
+            const errSnippet = event.content.length > 150 ? event.content.slice(0, 150) + "..." : event.content;
+            parts.push(`${emoji} Error encountered: ${errSnippet}`);
+          } else {
+            parts.push(`${emoji} Struggling with the current task.`);
+          }
+          if (this.currentTask) {
+            parts.push(`Working on: ${this.currentTask}`);
+          }
+          if (this.consecutiveFailures >= 5) {
+            parts.push("May need guidance or a different approach.");
+          }
+        }
+        return parts.join("\n");
+      }
+      /** Summarize recent tool activity into a brief phrase */
+      describeRecentActivity() {
+        if (this.recentTools.length === 0)
+          return "";
+        const counts = /* @__PURE__ */ new Map();
+        for (const t of this.recentTools) {
+          counts.set(t.name, (counts.get(t.name) ?? 0) + 1);
+        }
+        const descriptions = [];
+        if (counts.has("file_edit") || counts.has("file_write")) {
+          descriptions.push("editing code");
+        }
+        if (counts.has("shell")) {
+          descriptions.push("running commands");
+        }
+        if (counts.has("grep_search") || counts.has("glob_find")) {
+          descriptions.push("searching codebase");
+        }
+        if (counts.has("web_fetch") || counts.has("web_search")) {
+          descriptions.push("researching");
+        }
+        if (counts.has("memory_write") || counts.has("memory_read")) {
+          descriptions.push("updating memory");
+        }
+        if (descriptions.length === 0)
+          return "";
+        return descriptions.length === 1 ? `Currently ${descriptions[0]}.` : `Currently ${descriptions.slice(0, -1).join(", ")} and ${descriptions[descriptions.length - 1]}.`;
+      }
     };
   }
 });
@@ -40041,6 +40378,7 @@ Execute this skill now. Follow the behavioral guidance above.`;
         }
         writeContent(() => renderUserMessage(`/${cmdResult.name}${cmdResult.args ? " " + cmdResult.args : ""}`));
         lastSubmittedPrompt = skillPrompt;
+        emotionEngine.setCurrentTask(`/${cmdResult.name}${cmdResult.args ? " " + cmdResult.args.slice(0, 80) : ""}`);
         try {
           statusBar.setProcessing(true);
           const task = startTask(skillPrompt, currentConfig, repoRoot, voiceEngine, {
@@ -40219,6 +40557,8 @@ Summarize or analyze this transcription as appropriate.`;
     const displayText = isImage ? `[Image: ${cleanPath}]` : inputLineCount > 1 ? `[pasted ${inputLineCount} lines]` : fullInput;
     writeContent(() => renderUserMessage(displayText));
     lastSubmittedPrompt = fullInput;
+    const taskPreview = fullInput.length > 100 ? fullInput.slice(0, 100) + "..." : fullInput;
+    emotionEngine.setCurrentTask(taskPreview);
     try {
       const memSnippets = gatherMemorySnippets(repoRoot);
       if (memSnippets.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.72.0",
+  "version": "0.73.0",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",