open-agents-ai 0.72.1 → 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 */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.72.1",
+  "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",