neoagent 3.1.1-beta.2 → 3.1.1-beta.3

package/server/routes/tasks.js

@@ -3,6 +3,7 @@ const router = express.Router();
 const { requireAuth } = require('../middleware/auth');
 const { sanitizeError } = require('../utils/security');
 const { getAgentIdFromRequest, resolveAgentId } = require('../services/agents/manager');
+const { TaskDeliveryTargetService } = require('../services/tasks/delivery_targets');
 
 router.use(requireAuth);
 
@@ -28,6 +29,22 @@ router.get('/catalog', (req, res) => {
   }
 });
 
+router.get('/delivery-targets', async (req, res) => {
+  try {
+    const agentId = resolveAgentId(req.session.userId, getAgentIdFromRequest(req));
+    const service = new TaskDeliveryTargetService({ app: req.app });
+    const targets = await service.listTargets(req.session.userId, {
+      agentId,
+      platform: req.query.platform,
+      q: req.query.q,
+    });
+    res.json(targets);
+  } catch (error) {
+    (req.app.locals.logger?.error || console.error)('[Tasks] Failed to discover delivery targets', error);
+    res.status(500).json({ error: sanitizeError(error) });
+  }
+});
+
 router.post('/', async (req, res) => {
   try {
     const tasks = req.app.locals.taskRuntime;

package/server/services/ai/tools.js

@@ -837,7 +837,7 @@ function getAvailableTools(app, options = {}) {
                 type: 'object',
                 properties: {
                     content: { type: 'string', description: 'The complete, self-contained fact. Must be readable standalone — no references to "above", "the dump", or "chat history". Write as a clear declarative sentence.' },
-                    category: { type: 'string', enum: ['user_fact', 'preference', 'personality', 'episodic'], description: 'user_fact: facts about the user (job, location, hardware...), preference: likes/dislikes/settings, personality: how to interact with them, episodic: events/tasks/learnings' },
+                    category: { type: 'string', enum: ['user_fact', 'preference', 'personality', 'episodic', 'procedural'], description: 'user_fact: facts about the user (job, location, hardware...), preference: likes/dislikes/settings, personality: how to interact with them, episodic: events/tasks/learnings, procedural: reusable workflows or repeatable tool-use procedures' },
                     importance: { type: 'number', description: 'Importance 1-10. 1=trivial, 5=default, 8+=critical. High-importance memories rank higher in recall.' }
                 },
                 required: ['content']

package/server/services/memory/consolidation.js

@@ -9,6 +9,7 @@ const MEMORY_CATEGORIES = new Set([
   'events',
   'tasks',
   'episodic',
+  'procedural',
   'assistant_self',
 ]);
 
@@ -99,6 +100,7 @@ function buildMemoryConsolidationInstructions(currentDateTime) {
     'Use relation="extends" when it adds compatible detail without replacing the prior fact.',
     'Use relation="derives" only for a strongly supported inference and lower its confidence.',
     'Use is_static=true only for stable identity or durable preference facts.',
+    'Use category="procedural" only for reusable workflows or repeatable tool-use procedures, not one-off task status.',
     'Set valid_from, valid_to, or forget_after as ISO-8601 timestamps when the thread provides temporal boundaries.',
     'Return an empty memory_candidates array when nothing is worth retaining.',
   ].join(' ');

package/server/services/memory/manager.js

@@ -26,6 +26,12 @@ const {
   findEmbeddingCandidates,
   replaceMemoryEmbeddingIndex,
 } = require('./embedding_index');
+const { getRouteCategoryBoost, routeMemoryQuery } = require('./routing');
+const {
+  getReinforcedStrength,
+  getRetentionScoreMultiplier,
+  isArchiveEligible,
+} = require('./retention');
 const { AGENT_DATA_DIR } = require('../../../runtime/paths');
 const { isMainAgent, resolveAgentId } = require('../agents/manager');
 const { buildFtsQuery } = require('../../db/ftsQuery');
@@ -72,6 +78,7 @@ const CATEGORIES = [
   'events',
   'tasks',
   'episodic',
+  'procedural',
   'assistant_self',
   'user_fact',
   'preference',
@@ -167,6 +174,9 @@ function serializeMemoryRow(row) {
     importance: Number(row.importance || 0),
     confidence: row.confidence == null ? 0.7 : Number(row.confidence),
     access_count: Number(row.access_count || 0),
+    memoryStrength: row.memory_strength == null ? 1 : Number(row.memory_strength),
+    lastAccessedAt: row.last_accessed_at || null,
+    pinned: Number(row.pinned || 0) === 1,
     archived: Number(row.archived || 0),
     created_at: row.created_at,
     updated_at: row.updated_at,
@@ -1729,9 +1739,9 @@ class MemoryManager {
       `INSERT OR IGNORE INTO memories (
         id, user_id, agent_id, category, scope_type, scope_id, source_type, source_id, source_label,
         stale_after_days, metadata_json, content, summary, importance, confidence, memory_hash, embedding,
-        embedding_provider, embedding_model, embedding_dimensions, embedded_at
+        memory_strength, pinned, embedding_provider, embedding_model, embedding_dimensions, embedded_at
       )
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
     ).run(
       id,
       userId,
@@ -1750,6 +1760,8 @@ class MemoryManager {
       confidence,
       memoryHash,
       embedding ? serializeEmbedding(embedding) : null,
+      1,
+      0,
       embeddingResult?.provider || null,
       embeddingResult?.model || null,
       embeddingResult?.dimensions || null,
@@ -1830,6 +1842,7 @@ class MemoryManager {
     const agentId = this._agentId(userId, options);
     const scope = normalizeScope(options.scope, agentId);
     const limit = Math.max(1, Math.min(Number(topK) || 6, 50));
+    const route = routeMemoryQuery(query);
 
     const suppliedQueryEmbedding = options.queryEmbedding;
     const queryVec = suppliedQueryEmbedding
@@ -1887,7 +1900,8 @@ class MemoryManager {
     const candidateIdList = [...candidateIds];
     const candidatePlaceholders = candidateIdList.map(() => '?').join(', ');
     let all = db.prepare(
-      `SELECT id, category, content, summary, importance, confidence, embedding, access_count, created_at, updated_at,
+      `SELECT id, category, content, summary, importance, confidence, embedding, access_count,
+              memory_strength, last_accessed_at, pinned, created_at, updated_at,
               scope_type, scope_id, source_type, source_id, source_label, stale_after_days, metadata_json
        FROM memories
        WHERE id IN (${candidatePlaceholders})
@@ -1987,12 +2001,17 @@ class MemoryManager {
       const ftsScore = lexicalRanks.has(mem.id) ? 0.42 : 0;
       const entityScore = entityRanks.has(mem.id) ? 0.48 : 0;
       const relationScore = relationRanks.has(mem.id) ? 0.36 : 0;
+      const directSignal = Math.max(mem.semanticScore, lexicalScore, ftsScore, entityScore, relationScore);
+      const routeScore = directSignal > 0.08
+        ? getRouteCategoryBoost(route, normalizeMemoryCategory(mem.category))
+        : 0;
       const baseScore = Math.max(
         mem.semanticScore * (0.65 + Number(mem.importance || 5) / 25),
         lexicalScore,
         ftsScore,
         entityScore,
         relationScore,
+        routeScore,
       );
       const score = scoreMemoryCandidate({
         semanticRank: semanticRanks.get(mem.id) ?? -1,
@@ -2003,7 +2022,7 @@ class MemoryManager {
         confidence: mem.confidence,
         accessCount: mem.access_count,
         freshness: computeFreshnessMultiplier(mem),
-      });
+      }) * getRetentionScoreMultiplier(mem);
       return {
         ...mem,
         score,
@@ -2013,6 +2032,8 @@ class MemoryManager {
           fullText: ftsScore,
           entity: entityScore,
           relation: relationScore,
+          route: routeScore,
+          routeIntent: route.intent,
           vectorCandidateRank: vectorRanks.get(mem.id) ?? -1,
           candidateCount: all.length,
         },
@@ -2026,9 +2047,19 @@ class MemoryManager {
 
     // Update access counts
     if (results.length) {
-      const ids = results.map(r => r.id);
-      const placeholders = ids.map(() => '?').join(',');
-      db.prepare(`UPDATE memories SET access_count = access_count + 1 WHERE id IN (${placeholders})`).run(...ids);
+      const updates = db.prepare(
+        `UPDATE memories
+         SET access_count = access_count + 1,
+             memory_strength = ?,
+             last_accessed_at = datetime('now')
+         WHERE id = ?`
+      );
+      const reinforce = db.transaction(() => {
+        for (const result of results) {
+          updates.run(getReinforcedStrength(result), result.id);
+        }
+      });
+      reinforce();
     }
 
     const enrichedResults = this._attachSourceContext(
@@ -2061,7 +2092,8 @@ class MemoryManager {
    */
   listMemories(userId, { category, limit = 50, offset = 0, includeArchived = false, agentId = null } = {}) {
     const scopedAgentId = this._agentId(userId, { agentId });
-    let sql = `SELECT id, category, content, summary, importance, confidence, access_count, archived, created_at, updated_at,
+    let sql = `SELECT id, category, content, summary, importance, confidence, access_count,
+                      memory_strength, last_accessed_at, pinned, archived, created_at, updated_at,
                       scope_type, scope_id, source_type, source_id, source_label, stale_after_days, metadata_json
                FROM memories WHERE user_id = ? AND agent_id = ? AND archived = ?`;
     const params = [userId, scopedAgentId, includeArchived ? 1 : 0];
@@ -2197,6 +2229,27 @@ class MemoryManager {
     return result.changes || 0;
   }
 
+  archiveWeakMemories(userId, options = {}) {
+    const agentId = this._agentId(userId, options);
+    const limit = Math.max(1, Math.min(Number(options.limit) || 100, 500));
+    const rows = db.prepare(
+      `SELECT id, category, importance, archived, memory_strength, last_accessed_at,
+              pinned, stale_after_days, created_at, updated_at
+       FROM memories
+       WHERE user_id = ? AND agent_id = ? AND archived = 0
+       ORDER BY updated_at ASC
+       LIMIT ?`
+    ).all(userId, agentId, limit);
+    const archiveIds = rows
+      .filter((row) => isArchiveEligible(row, options))
+      .map((row) => row.id);
+    return {
+      scanned: rows.length,
+      archived: this.archiveMemories(archiveIds, true, userId),
+      memoryIds: archiveIds,
+    };
+  }
+
   // ─────────────────────────────────────────────────────────────────────────
   // Core Memory (always-injected key-value pairs)
   // ─────────────────────────────────────────────────────────────────────────
@@ -2942,7 +2995,14 @@ class MemoryManager {
       if (recalled.length) {
         const memoryLines = [];
         let memoryChars = 0;
+        const seenMemoryText = new Set();
+        const categoryCounts = new Map();
         for (const m of recalled) {
+          const category = normalizeMemoryCategory(m.category);
+          const summaryKey = stableHash(summarizeForPrompt(m).slice(0, 220));
+          if (seenMemoryText.has(summaryKey)) continue;
+          const categoryCount = categoryCounts.get(category) || 0;
+          if (memoryLines.length >= 3 && categoryCount >= 2) continue;
           const badge = m.category !== 'episodic' ? ` [${m.category}]` : '';
           const entities = Array.isArray(m.entities) && m.entities.length
             ? ` (entities: ${m.entities.slice(0, 4).map((entity) => entity.name).join(', ')})`
@@ -2963,6 +3023,8 @@ class MemoryManager {
           const line = `- ${summarizeForPrompt(m)}${badge}${entities}${historySuffix}${sourceSuffix}`;
           if (memoryLines.length && memoryChars + line.length > 1600) break;
           memoryLines.push(line);
+          seenMemoryText.add(summaryKey);
+          categoryCounts.set(category, categoryCount + 1);
           memoryChars += line.length;
         }
         sections.push(`Relevant memory:\n${memoryLines.join('\n')}`);

package/server/services/memory/retention.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const PROTECTED_CATEGORIES = new Set(['identity', 'preferences', 'assistant_self']);
+
+function clamp(value, min, max, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) ? Math.max(min, Math.min(max, number)) : fallback;
+}
+
+function parseTime(value) {
+  const timestamp = Date.parse(String(value || ''));
+  return Number.isFinite(timestamp) ? timestamp : null;
+}
+
+function ageDaysSince(value, now = Date.now()) {
+  const timestamp = parseTime(value);
+  if (!timestamp) return 0;
+  return Math.max(0, (now - timestamp) / (1000 * 60 * 60 * 24));
+}
+
+function isPinnedMemory(memory) {
+  if (Number(memory?.pinned || 0) === 1) return true;
+  if (PROTECTED_CATEGORIES.has(String(memory?.category || ''))) return true;
+  return Number(memory?.importance || 0) >= 9;
+}
+
+function getDecayedStrength(memory, now = Date.now()) {
+  const strength = clamp(memory?.memory_strength, 0.05, 2, 1);
+  if (isPinnedMemory(memory)) return strength;
+  const halfLifeDays = clamp(memory?.stale_after_days, 14, 365, 90);
+  const lastRelevantAt = memory?.last_accessed_at || memory?.updated_at || memory?.created_at;
+  const age = ageDaysSince(lastRelevantAt, now);
+  return clamp(strength * Math.pow(0.5, age / halfLifeDays), 0.01, 2, strength);
+}
+
+function getRetentionScoreMultiplier(memory, now = Date.now()) {
+  if (isPinnedMemory(memory)) return 1.04;
+  const decayed = getDecayedStrength(memory, now);
+  return clamp(0.82 + (decayed * 0.14), 0.65, 1.08, 1);
+}
+
+function getReinforcedStrength(memory) {
+  const current = clamp(memory?.memory_strength, 0.05, 2, 1);
+  const importanceBoost = clamp(memory?.importance, 1, 10, 5) / 250;
+  return clamp(current + 0.06 + importanceBoost, 0.05, 2, 1.08);
+}
+
+function isArchiveEligible(memory, options = {}) {
+  if (!memory || isPinnedMemory(memory)) return false;
+  if (Number(memory.archived || 0) === 1) return false;
+  if (Number(memory.importance || 0) >= 8) return false;
+
+  const now = options.now || Date.now();
+  const minAgeDays = clamp(options.minAgeDays, 1, 365, 45);
+  const threshold = clamp(options.strengthThreshold, 0.01, 1, 0.18);
+  const age = ageDaysSince(memory.updated_at || memory.created_at, now);
+  return age >= minAgeDays && getDecayedStrength(memory, now) < threshold;
+}
+
+module.exports = {
+  getDecayedStrength,
+  getReinforcedStrength,
+  getRetentionScoreMultiplier,
+  isArchiveEligible,
+  isPinnedMemory,
+};

package/server/services/memory/routing.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const INTENTS = new Set(['broad', 'procedural', 'episodic', 'profile']);
+
+function hasAny(text, patterns) {
+  return patterns.some((pattern) => pattern.test(text));
+}
+
+function normalizeIntent(intent) {
+  return INTENTS.has(intent) ? intent : 'broad';
+}
+
+function routeMemoryQuery(query) {
+  const text = String(query || '').toLowerCase();
+  if (!text.trim()) {
+    return { intent: 'broad', confidence: 0, categoryBoosts: {} };
+  }
+
+  const procedural = hasAny(text, [
+    /\bhow (?:do|did|should|can) (?:i|we|you)\b/,
+    /\b(?:workflow|procedure|runbook|playbook|steps?|checklist|process)\b/,
+    /\b(?:repeat|reusable|again|same way|tool[- ]use|command sequence)\b/,
+  ]);
+  if (procedural) {
+    return {
+      intent: 'procedural',
+      confidence: 0.76,
+      categoryBoosts: { procedural: 0.26, tasks: 0.08, episodic: 0.04 },
+    };
+  }
+
+  const episodic = hasAny(text, [
+    /\b(?:when|what happened|last time|previously|yesterday|today|last week|last month)\b/,
+    /\b(?:meeting|event|conversation|session|incident|task run)\b/,
+  ]);
+  if (episodic) {
+    return {
+      intent: 'episodic',
+      confidence: 0.7,
+      categoryBoosts: { episodic: 0.18, events: 0.16, tasks: 0.1 },
+    };
+  }
+
+  const profile = hasAny(text, [
+    /\b(?:prefer|preference|likes?|dislikes?|my name|who am i|about me)\b/,
+    /\b(?:profile|personality|standing instruction|how should you)\b/,
+  ]);
+  if (profile) {
+    return {
+      intent: 'profile',
+      confidence: 0.72,
+      categoryBoosts: { preferences: 0.2, identity: 0.16, assistant_self: 0.12 },
+    };
+  }
+
+  return { intent: 'broad', confidence: 0.35, categoryBoosts: {} };
+}
+
+function getRouteCategoryBoost(route, category) {
+  const intent = normalizeIntent(route?.intent);
+  if (intent === 'broad' || Number(route?.confidence || 0) < 0.6) return 0;
+  return Number(route?.categoryBoosts?.[category] || 0);
+}
+
+module.exports = {
+  getRouteCategoryBoost,
+  routeMemoryQuery,
+};

package/server/services/messaging/access_policy.js

@@ -37,7 +37,7 @@ const SHARED_RAW_ID_PLATFORMS = new Set([
   'webchat',
 ]);
 
-const DIRECT_ONLY_PHONE_PLATFORMS = new Set(['telnyx', 'whatsapp']);
+const DIRECT_ONLY_PHONE_PLATFORMS = new Set(['telnyx']);
 
 function capabilityTemplate(overrides = {}) {
   return Object.freeze({
@@ -300,6 +300,17 @@ function addRule(bucket, rule, state) {
   state[bucket].push(rule);
 }
 
+function isWhatsAppGroupId(value) {
+  return String(value || '').trim().toLowerCase().split(':')[0].endsWith('@g.us');
+}
+
+function normalizeWhatsAppDirectId(value) {
+  const raw = String(value || '').trim().toLowerCase();
+  const base = raw.includes('@') ? raw.split('@')[0] : raw;
+  const primary = base.includes(':') ? base.split(':')[0] : base;
+  return primary.replace(/\D/g, '') || primary;
+}
+
 function migrateLegacyWhitelist(platform, entries) {
   const capabilities = getPlatformAccessCapabilities(platform);
   const policy = createDefaultAccessPolicy(platform);
@@ -328,6 +339,22 @@ function migrateLegacyWhitelist(platform, entries) {
     const value = sanitizeValue(scope || 'chat', rawValue);
     if (!value) continue;
 
+    if (platform === 'whatsapp') {
+      if (scope === 'group' || isWhatsAppGroupId(value)) {
+        addRule('sharedSpaceRules', normalizeRule({ scope: 'group', value }, new Set(capabilities.sharedSpaceRuleScopes)), state);
+        continue;
+      }
+      const directValue = scope === 'chat' ? value : normalizeWhatsAppDirectId(value);
+      if (!directValue) continue;
+      if (scope === 'chat') {
+        addRule('directRules', normalizeRule({ scope: 'chat', value: directValue }, new Set(capabilities.directRuleScopes)), state);
+      } else {
+        addRule('directRules', normalizeRule({ scope: 'phone_number', value: directValue }, new Set(capabilities.directRuleScopes)), state);
+        addRule('sharedActorRules', normalizeRule({ scope: 'phone_number', value: directValue }, new Set(capabilities.sharedActorRuleScopes)), state);
+      }
+      continue;
+    }
+
     if (DIRECT_ONLY_PHONE_PLATFORMS.has(platform)) {
       addRule('directRules', normalizeRule({ scope: 'phone_number', value }, new Set(capabilities.directRuleScopes)), state);
       continue;
@@ -641,7 +668,17 @@ function classifyRecentTarget(platform, row) {
   if (!chatId && !sender) return null;
 
   const isDirect = !String(metadata.isGroup || '').match(/^(true|1)$/i) && (!chatId || chatId === sender || chatId === `dm_${sender}`);
-  if (DIRECT_ONLY_PHONE_PLATFORMS.has(platform)) {
+  if (platform === 'whatsapp' && !isDirect && chatId) {
+    return {
+      source: 'recent',
+      bucket: 'sharedSpaceRules',
+      scope: 'group',
+      value: chatId,
+      label: groupName || chatId,
+      subtitle: 'Recent WhatsApp group',
+    };
+  }
+  if (DIRECT_ONLY_PHONE_PLATFORMS.has(platform) || platform === 'whatsapp') {
     const value = normalizePhone(sender || chatId);
     if (!value) return null;
     return {

package/server/services/messaging/manager.js

@@ -818,14 +818,19 @@ class MessagingManager extends EventEmitter {
     );
   }
 
-  async getAccessCatalog(userId, platformName, options = {}) {
+  async listAccessTargets(userId, platformName, options = {}) {
     const agentId = this._agentId(userId, options);
     const key = this._key(userId, agentId, platformName);
     const platform = this.platforms.get(key);
-    let discoveredTargets = [];
-    if (platform?.listAccessTargets) {
-      discoveredTargets = await Promise.resolve(platform.listAccessTargets()).catch(() => []);
+    if (!platform || typeof platform.listAccessTargets !== 'function') {
+      return [];
     }
+    return Promise.resolve(platform.listAccessTargets()).catch(() => []);
+  }
+
+  async getAccessCatalog(userId, platformName, options = {}) {
+    const agentId = this._agentId(userId, options);
+    const discoveredTargets = await this.listAccessTargets(userId, platformName, { agentId });
 
     const recentRows = db.prepare(
       `SELECT platform_chat_id, metadata