neoagent 2.3.1-beta.3 → 2.3.1-beta.31

package/server/services/manager.js

@@ -25,6 +25,7 @@ const { BrowserExtensionRegistry } = require('./browser/extension/registry');
 const { DesktopCompanionRegistry } = require('./desktop/registry');
 const { DesktopProvider } = require('./desktop/provider');
 const { ScreenRecorder } = require('./desktop/screenRecorder');
+const { WearableService } = require('./wearable/service');
 const { assertRuntimeValidation, getRuntimeValidation } = require('./runtime/validation');
 const {
   getErrorMessage,
@@ -429,11 +430,46 @@ function createWidgetService(app) {
   return widgetService;
 }
 
+function createWearableService(app) {
+  const wearableService = registerLocal(
+    app,
+    'wearableService',
+    new WearableService({ app }),
+  );
+  logServiceReady('Wearable service ready');
+  return wearableService;
+}
+
 function createScreenRecorder(app) {
+  const hasActiveRemoteCaptureSession = () => {
+    const desktopRegistry = app.locals.desktopCompanionRegistry;
+    if (desktopRegistry?.connectionsByUser instanceof Map) {
+      for (const userMap of desktopRegistry.connectionsByUser.values()) {
+        if (!(userMap instanceof Map)) continue;
+        for (const connection of userMap.values()) {
+          if (typeof connection?.isOpen === 'function' && connection.isOpen()) {
+            return true;
+          }
+        }
+      }
+    }
+
+    const extensionRegistry = app.locals.browserExtensionRegistry;
+    if (extensionRegistry?.connectionsByUser instanceof Map) {
+      for (const connection of extensionRegistry.connectionsByUser.values()) {
+        if (typeof connection?.isOpen === 'function' && connection.isOpen()) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  };
+
   const screenRecorder = registerLocal(
     app,
     'screenRecorder',
-    new ScreenRecorder(),
+    new ScreenRecorder({ hasActiveRemoteCaptureSession }),
   );
   screenRecorder.start();
   logServiceReady('Screen recorder started');
@@ -525,6 +561,7 @@ async function startServices(app, io) {
     const messagingManager = createMessagingManager(app, io, agentEngine);
     const recordingManager = createRecordingManager(app, io);
     createWidgetService(app);
+    createWearableService(app);
     createScreenRecorder(app);
 
     restoreMessagingConnections(messagingManager);
@@ -589,6 +626,14 @@ async function stopServices(app) {
     );
   }
 
+  if (app.locals.wearableGateway?.close) {
+    tasks.push(
+      app.locals.wearableGateway.close().catch((err) => {
+        console.error('[WearableGateway] Shutdown error:', getErrorMessage(err));
+      }),
+    );
+  }
+
   if (app.locals.browserControllers instanceof Map) {
     for (const controller of app.locals.browserControllers.values()) {
       tasks.push(

package/server/services/memory/manager.js

@@ -12,6 +12,11 @@ const {
 const { getMemoryStorageDecision } = require('./policy');
 const { AGENT_DATA_DIR } = require('../../../runtime/paths');
 const { isMainAgent, resolveAgentId } = require('../agents/manager');
+const {
+  decryptLocalValue,
+  encryptLocalValue,
+  isLocalEncryptedValue,
+} = require('../../utils/local_secrets');
 
 async function getActiveProvider(userId, agentId = null) {
   try {
@@ -516,11 +521,43 @@ class MemoryManager {
         return {};
       }
     }
-    try { return JSON.parse(fs.readFileSync(filePath, 'utf-8')); } catch { return {}; }
+    try {
+      const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+      if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return {};
+      }
+
+      let shouldMigrate = false;
+      const normalized = {};
+
+      for (const [service, rawValue] of Object.entries(parsed)) {
+        const value = String(rawValue || '');
+        if (!value) {
+          normalized[service] = '';
+          continue;
+        }
+
+        if (!isLocalEncryptedValue(value)) shouldMigrate = true;
+        normalized[service] = decryptLocalValue(value);
+      }
+
+      if (shouldMigrate) {
+        this.writeApiKeys(normalized, userId);
+      }
+
+      return normalized;
+    } catch {
+      return {};
+    }
   }
 
   writeApiKeys(keys, userId = null) {
-    fs.writeFileSync(this._userApiKeysPath(userId), JSON.stringify(keys, null, 2), 'utf-8');
+    const encrypted = {};
+    for (const [service, rawValue] of Object.entries(keys || {})) {
+      const value = String(rawValue || '');
+      encrypted[service] = value ? encryptLocalValue(value) : '';
+    }
+    fs.writeFileSync(this._userApiKeysPath(userId), JSON.stringify(encrypted, null, 2), 'utf-8');
   }
 
   setApiKey(service, key, userId = null) {

package/server/services/messaging/access_policy.js

@@ -165,6 +165,16 @@ const PLATFORM_CAPABILITIES = Object.freeze({
     sharedSpaceRuleScopes: Object.freeze(['channel', 'chat']),
     sharedActorRuleScopes: Object.freeze(['user']),
   }),
+  meshtastic: capabilityTemplate({
+    supportsDirectPolicy: false,
+    supportsSharedPolicy: true,
+    supportsMentionGate: false,
+    supportsDiscovery: false,
+    directRuleScopes: Object.freeze([]),
+    sharedSpaceRuleScopes: Object.freeze(['channel', 'chat']),
+    sharedActorRuleScopes: Object.freeze(['user']),
+    manualEntryHint: 'Add a Meshtastic node number or channel id.',
+  }),
   feishu: capabilityTemplate({ supportsDiscovery: false }),
   nextcloud_talk: capabilityTemplate({ supportsDiscovery: false }),
   nostr: capabilityTemplate({ supportsDiscovery: false }),

package/server/services/messaging/manager.js

@@ -9,6 +9,7 @@ const { WhatsAppPlatform } = require('./whatsapp');
 const { TelnyxVoicePlatform } = require('./telnyx');
 const { DiscordPlatform } = require('./discord');
 const { TelegramPlatform } = require('./telegram');
+const { MeshtasticPlatform } = require('./meshtastic');
 const {
   SlackPlatform,
   GoogleChatPlatform,
@@ -34,6 +35,7 @@ const {
   classifyRecentTarget,
 } = require('./access_policy');
 const { decryptValue, encryptValue } = require('../integrations/secrets');
+const { readMeshtasticEnabled } = require('./meshtastic_env');
 
 const LEGACY_WHATSAPP_AUTH_DIR = path.join(DATA_DIR, 'whatsapp-auth');
 
@@ -78,6 +80,7 @@ class MessagingManager extends EventEmitter {
       feishu: createGenericPlatformClass('feishu'),
       line: LinePlatform,
       mattermost: MattermostPlatform,
+      meshtastic: MeshtasticPlatform,
       nextcloud_talk: createGenericPlatformClass('nextcloud_talk'),
       nostr: createGenericPlatformClass('nostr'),
       synology_chat: createGenericPlatformClass('synology_chat'),
@@ -302,6 +305,9 @@ class MessagingManager extends EventEmitter {
     config.accessPolicy = this._loadAccessPolicy(userId, agentId, platformName);
     const PlatformClass = this.platformTypes[platformName];
     if (!PlatformClass) throw new Error(`Unknown platform: ${platformName}`);
+    if (platformName === 'meshtastic' && !readMeshtasticEnabled()) {
+      throw new Error('Meshtastic is disabled by environment configuration');
+    }
 
     if (platformName === 'whatsapp' && !config.authDir) {
       config.authDir = this._scopedPlatformAuthDir(userId, agentId, platformName);
@@ -545,6 +551,14 @@ class MessagingManager extends EventEmitter {
 
   getPlatformStatus(userId, platformName, options = {}) {
     const agentId = this._agentId(userId, options);
+    if (platformName === 'meshtastic' && !readMeshtasticEnabled()) {
+      return {
+        status: 'disabled',
+        authInfo: {
+          label: 'Disabled in env',
+        },
+      };
+    }
     const key = this._key(userId, agentId, platformName);
     const platform = this.platforms.get(key);
     if (!platform) {
@@ -562,7 +576,21 @@ class MessagingManager extends EventEmitter {
     const connections = db.prepare('SELECT platform, status, last_connected, agent_id FROM platform_connections WHERE user_id = ? AND agent_id = ?').all(userId, agentId);
     const statuses = {};
 
+    if (!readMeshtasticEnabled()) {
+      statuses.meshtastic = {
+        status: 'disabled',
+        agentId,
+        lastConnected: null,
+        authInfo: {
+          label: 'Disabled in env',
+        },
+      };
+    }
+
     for (const conn of connections) {
+      if (conn.platform === 'meshtastic' && !readMeshtasticEnabled()) {
+        continue;
+      }
       const key = this._key(userId, agentId, conn.platform);
       const platform = this.platforms.get(key);
       statuses[conn.platform] = {
@@ -616,6 +644,11 @@ class MessagingManager extends EventEmitter {
     ).all();
     for (const row of rows) {
       try {
+        if (row.platform === 'meshtastic' && !readMeshtasticEnabled()) {
+          db.prepare("UPDATE platform_connections SET status = 'disabled' WHERE user_id = ? AND agent_id = ? AND platform = ?")
+            .run(row.user_id, row.agent_id, row.platform);
+          continue;
+        }
         const config = this._decodeStoredConfig(row.config);
         console.log(`[Messaging] Restoring ${row.platform} for user ${row.user_id} agent ${row.agent_id || 'main'}`);
         await this.connectPlatform(row.user_id, row.platform, config, { agentId: row.agent_id });
@@ -627,6 +660,22 @@ class MessagingManager extends EventEmitter {
     }
   }
 
+  async updateMeshtasticEnabled(enabled) {
+    if (enabled) return;
+    const disconnects = [];
+    for (const [key, platform] of this.platforms.entries()) {
+      if (!key.endsWith(':meshtastic')) continue;
+      disconnects.push(
+        Promise.resolve(platform.disconnect()).catch(() => {}).then(() => {
+          this.platforms.delete(key);
+        })
+      );
+    }
+    await Promise.all(disconnects);
+    db.prepare("UPDATE platform_connections SET status = 'disabled' WHERE platform = 'meshtastic'")
+      .run();
+  }
+
   async shutdown() {
     this.isShuttingDown = true;
 

package/server/services/messaging/meshtastic.js

@@ -0,0 +1,322 @@
+'use strict';
+
+const { BasePlatform } = require('./base');
+const { readMeshtasticEnabled } = require('./meshtastic_env');
+
+const DEFAULT_TCP_PORT = 4403;
+const DEFAULT_CHANNEL = 0;
+
+let meshtasticModulesPromise = null;
+
+function requireText(value, label) {
+  const text = String(value || '').trim();
+  if (!text) throw new Error(`${label} is required`);
+  return text;
+}
+
+function parseTcpHost(input) {
+  const raw = requireText(input, 'Meshtastic device IP address');
+  if (raw.startsWith('[')) {
+    const match = raw.match(/^\[([^\]]+)\](?::(\d+))?$/);
+    if (!match) {
+      throw new Error('Meshtastic device IP address is invalid');
+    }
+    return {
+      host: match[1],
+      port: match[2] ? Number(match[2]) : DEFAULT_TCP_PORT,
+    };
+  }
+
+  const parts = raw.split(':');
+  if (parts.length === 2 && /^\d+$/.test(parts[1])) {
+    return {
+      host: parts[0],
+      port: Number(parts[1]),
+    };
+  }
+
+  return { host: raw, port: DEFAULT_TCP_PORT };
+}
+
+function parseChannel(value) {
+  const channel = Number(String(value ?? DEFAULT_CHANNEL).trim() || DEFAULT_CHANNEL);
+  if (!Number.isInteger(channel) || channel < 0 || channel > 6) {
+    throw new Error('Meshtastic channel must be an integer from 0 to 6');
+  }
+  return channel;
+}
+
+async function loadMeshtasticModules() {
+  if (!meshtasticModulesPromise) {
+    meshtasticModulesPromise = Promise.all([
+      import('@meshtastic/core'),
+      import('@meshtastic/transport-node'),
+    ]).then(([core, transport]) => ({
+      MeshDevice: core.MeshDevice,
+      Types: core.Types,
+      TransportNode: transport.TransportNode,
+    }));
+  }
+  return meshtasticModulesPromise;
+}
+
+function normalizeNodeId(value) {
+  const text = String(value || '').trim();
+  if (!text) return '';
+  return text.startsWith('!') ? text : `!${text}`;
+}
+
+function toIsoTimestamp(value) {
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    const normalized = value < 1e12 ? value * 1000 : value;
+    return new Date(normalized).toISOString();
+  }
+  return new Date().toISOString();
+}
+
+class MeshtasticPlatform extends BasePlatform {
+  constructor(config = {}) {
+    super('meshtastic', config);
+    this.supportsGroups = true;
+    this.supportsMedia = false;
+    this.supportsVoice = false;
+    this.status = 'disconnected';
+    this.host = null;
+    this.port = DEFAULT_TCP_PORT;
+    this.channel = DEFAULT_CHANNEL;
+    this.authInfo = null;
+    this._transport = null;
+    this._device = null;
+    this._modules = null;
+    this._connectPromise = null;
+    this._disconnecting = false;
+    this._configured = false;
+    this._lastMyNodeInfo = null;
+    this._lastNodeUsers = new Map();
+  }
+
+  async connect() {
+    if (!readMeshtasticEnabled()) {
+      throw new Error('Meshtastic is disabled by environment configuration');
+    }
+
+    if (this._connectPromise) {
+      return this._connectPromise;
+    }
+
+    this._connectPromise = this._connect();
+    try {
+      return await this._connectPromise;
+    } finally {
+      this._connectPromise = null;
+    }
+  }
+
+  async _connect() {
+    const endpoint = parseTcpHost(this.config.host || this.config.ipAddress || this.config.baseUrl);
+    this.host = endpoint.host;
+    this.port = endpoint.port;
+    this.channel = parseChannel(this.config.channel);
+    this._disconnecting = false;
+    this._configured = false;
+    this._lastMyNodeInfo = null;
+    this._lastNodeUsers.clear();
+    this.status = 'connecting';
+
+    const modules = await loadMeshtasticModules();
+    this._modules = modules;
+
+    const transport = await modules.TransportNode.create(this.host, this.port, 60000);
+    this._transport = transport;
+
+    const device = new modules.MeshDevice(transport);
+    this._device = device;
+    this._wireDeviceEvents(device, modules.Types);
+
+    const ready = new Promise((resolve, reject) => {
+      let settled = false;
+      const resolveOnce = () => {
+        if (settled) return;
+        settled = true;
+        resolve({ status: this.status });
+      };
+      const rejectOnce = (error) => {
+        if (settled) return;
+        settled = true;
+        reject(error);
+      };
+
+      device.events.onDeviceStatus.subscribe((status) => {
+        if (status === modules.Types.DeviceStatusEnum.DeviceConnected) {
+          device.configure().catch((error) => {
+            if (!this._disconnecting) {
+              rejectOnce(error);
+            }
+          });
+          return;
+        }
+
+        if (status === modules.Types.DeviceStatusEnum.DeviceConfigured) {
+          this._configured = true;
+          this.status = 'connected';
+          this.authInfo = this._buildAuthInfo();
+          this.emit('connected');
+          resolveOnce();
+          return;
+        }
+
+        if (status === modules.Types.DeviceStatusEnum.DeviceDisconnected) {
+          this.status = 'disconnected';
+          if (!this._disconnecting) {
+            const error = new Error('Meshtastic device disconnected');
+            rejectOnce(error);
+            this.emit('disconnected', { reason: 'device_disconnected' });
+          }
+        }
+      });
+    });
+
+    await ready;
+    return { status: this.status };
+  }
+
+  _wireDeviceEvents(device, Types) {
+    device.events.onMyNodeInfo.subscribe((info) => {
+      this._lastMyNodeInfo = info;
+      this.authInfo = this._buildAuthInfo();
+    });
+
+    device.events.onUserPacket.subscribe((packet) => {
+      const user = packet?.data;
+      const from = Number(packet?.from || 0);
+      if (!user || !Number.isFinite(from) || from <= 0) return;
+      this._lastNodeUsers.set(from, user);
+    });
+
+    device.events.onMessagePacket.subscribe((packet) => {
+      if (!packet) return;
+      const channel = Number(packet.channel);
+      if (channel !== this.channel) return;
+
+      const senderNum = Number(packet.from || 0);
+      const localNodeNum = Number(this._lastMyNodeInfo?.myNodeNum || 0);
+      if (senderNum > 0 && localNodeNum > 0 && senderNum === localNodeNum) {
+        return;
+      }
+      const senderUser = this._lastNodeUsers.get(senderNum) || null;
+      const senderName = senderUser?.longName || senderUser?.shortName || null;
+      const senderUsername = normalizeNodeId(senderUser?.id || '');
+      const chatId = `channel:${channel}`;
+
+      const access = this._checkInboundAccess({
+        platform: this.name,
+        senderId: String(senderNum || ''),
+        chatId,
+        isDirect: false,
+        isShared: true,
+        groupId: chatId,
+        channelId: chatId,
+        serverId: '',
+        roomId: chatId,
+        roleIds: [],
+        phoneNumber: '',
+        wasMentioned: false,
+      }, {
+        senderName,
+        groupLabel: chatId,
+        channelLabel: chatId,
+        roomLabel: chatId,
+      });
+
+      if (!access.allowed) return;
+
+      this.emit('message', {
+        chatId,
+        sender: String(senderNum || ''),
+        senderName,
+        senderUsername: senderUsername || null,
+        senderTag: senderUsername || null,
+        content: String(packet.data || ''),
+        mediaType: null,
+        isGroup: true,
+        messageId: String(packet.id || `${Date.now()}`),
+        timestamp: toIsoTimestamp(packet.rxTime),
+        metadata: {
+          channel,
+          host: this.host,
+          meshNodeId: senderUsername || null,
+          meshDestination: packet.type || 'broadcast',
+        },
+        rawMessage: {
+          id: packet.id,
+          from: packet.from,
+          to: packet.to,
+          type: packet.type,
+          channel: packet.channel,
+        },
+      });
+    });
+  }
+
+  _buildAuthInfo() {
+    const info = this._lastMyNodeInfo || {};
+    const user = info.user || {};
+    return {
+      label: user.longName || user.shortName || normalizeNodeId(user.id) || this.host || 'Meshtastic',
+      nodeId: normalizeNodeId(user.id),
+      host: this.host,
+      channel: this.channel,
+    };
+  }
+
+  async sendMessage(to, content) {
+    if (this.status !== 'connected' || !this._device || !this._modules) {
+      throw new Error('Meshtastic is not connected');
+    }
+
+    const chatId = String(to || '').trim();
+    if (chatId && chatId !== `channel:${this.channel}` && chatId !== String(this.channel)) {
+      throw new Error(`Meshtastic is configured for channel ${this.channel}`);
+    }
+
+    await this._device.sendText(
+      String(content || ''),
+      'broadcast',
+      true,
+      this.channel,
+    );
+    return { success: true };
+  }
+
+  async disconnect() {
+    this._disconnecting = true;
+    this.status = 'disconnected';
+
+    const device = this._device;
+    const transport = this._transport;
+    this._device = null;
+    this._transport = null;
+    this._configured = false;
+
+    if (device && typeof device.disconnect === 'function') {
+      await device.disconnect().catch(() => {});
+    } else if (transport && typeof transport.disconnect === 'function') {
+      await transport.disconnect().catch(() => {});
+    }
+  }
+
+  async logout() {
+    await this.disconnect();
+  }
+
+  getAuthInfo() {
+    return this.authInfo || this._buildAuthInfo();
+  }
+}
+
+module.exports = {
+  MeshtasticPlatform,
+  parseChannel,
+  parseTcpHost,
+};

package/server/services/messaging/meshtastic_env.js

@@ -0,0 +1,100 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { ENV_FILE } = require('../../../runtime/paths');
+const { parseEnv } = require('../../../runtime/env');
+
+const MESHTASTIC_ENABLED_ENV_KEY = 'MESHTASTIC_ENABLED';
+const FALSE_VALUES = new Set(['0', 'false', 'no', 'off', 'disabled']);
+
+function normalizeMeshtasticEnabled(value, fallback = true) {
+  if (value == null) return fallback;
+  const normalized = String(value).trim().toLowerCase();
+  if (!normalized) return fallback;
+  return !FALSE_VALUES.has(normalized);
+}
+
+function readEnvFileRaw(envFile = ENV_FILE) {
+  if (!fs.existsSync(envFile)) return '';
+  return fs.readFileSync(envFile, 'utf8');
+}
+
+function writeEnvFileValue(key, value, envFile = ENV_FILE) {
+  const raw = readEnvFileRaw(envFile);
+  const lines = raw ? raw.split('\n') : [];
+  let replaced = false;
+
+  for (let i = 0; i < lines.length; i += 1) {
+    if (lines[i].startsWith(`${key}=`)) {
+      lines[i] = `${key}=${value}`;
+      replaced = true;
+      break;
+    }
+  }
+
+  if (!replaced) {
+    lines.push(`${key}=${value}`);
+  }
+
+  const output = `${lines
+    .filter((_, idx, items) => idx !== items.length - 1 || items[idx] !== '')
+    .join('\n')}\n`;
+  fs.mkdirSync(path.dirname(envFile), { recursive: true });
+  fs.writeFileSync(envFile, output, { mode: 0o600 });
+}
+
+function removeEnvFileValue(key, envFile = ENV_FILE) {
+  const raw = readEnvFileRaw(envFile);
+  if (!raw) return false;
+  const lines = raw.split('\n').filter((line) => !line.startsWith(`${key}=`));
+  const output = `${lines
+    .filter((_, idx, items) => idx !== items.length - 1 || items[idx] !== '')
+    .join('\n')}\n`;
+  fs.mkdirSync(path.dirname(envFile), { recursive: true });
+  fs.writeFileSync(envFile, output, { mode: 0o600 });
+  return true;
+}
+
+function readMeshtasticEnabled({
+  env = process.env,
+  envFile = ENV_FILE,
+  fallback = true,
+} = {}) {
+  const envValue = env?.[MESHTASTIC_ENABLED_ENV_KEY];
+  if (envValue != null && String(envValue).trim()) {
+    return normalizeMeshtasticEnabled(envValue, fallback);
+  }
+  const parsed = parseEnv(readEnvFileRaw(envFile));
+  return normalizeMeshtasticEnabled(parsed.get(MESHTASTIC_ENABLED_ENV_KEY), fallback);
+}
+
+function setMeshtasticEnabled(enabled, {
+  env = process.env,
+  envFile = ENV_FILE,
+} = {}) {
+  const normalized = normalizeMeshtasticEnabled(enabled, true);
+  writeEnvFileValue(MESHTASTIC_ENABLED_ENV_KEY, normalized ? 'true' : 'false', envFile);
+  if (env && typeof env === 'object') {
+    env[MESHTASTIC_ENABLED_ENV_KEY] = normalized ? 'true' : 'false';
+  }
+  return normalized;
+}
+
+function resetMeshtasticEnabled({
+  env = process.env,
+  envFile = ENV_FILE,
+} = {}) {
+  removeEnvFileValue(MESHTASTIC_ENABLED_ENV_KEY, envFile);
+  if (env && typeof env === 'object') {
+    delete env[MESHTASTIC_ENABLED_ENV_KEY];
+  }
+}
+
+module.exports = {
+  MESHTASTIC_ENABLED_ENV_KEY,
+  normalizeMeshtasticEnabled,
+  readMeshtasticEnabled,
+  setMeshtasticEnabled,
+  resetMeshtasticEnabled,
+};

package/server/services/tasks/runtime.js

@@ -296,7 +296,7 @@ class TaskRuntime {
       if (normalizedConfig.callTo) {
         notifyHint = `\n\nThis task is configured to notify the user by phone. Use the make_call tool to call "${normalizedConfig.callTo}" with an appropriate greeting based on your findings. The configured greeting hint is: "${normalizedConfig.callGreeting || 'Hello, this is your task reminder.'}"`;
       } else if (normalizedConfig.notifyPlatform && normalizedConfig.notifyTo) {
-        notifyHint = `\n\nIf your task result is worth notifying the user about, send it proactively via send_message to platform="${normalizedConfig.notifyPlatform}" to="${normalizedConfig.notifyTo}".`;
+        notifyHint = `\n\nIf your task result is worth notifying the user about, send it proactively via send_message to platform="${normalizedConfig.notifyPlatform}" to="${normalizedConfig.notifyTo}" and set purpose="final_result" for a concrete useful outcome or purpose="blocker" for a real issue the user should know about. If nothing important or actionable changed, call send_message with purpose="no_response" and content="[NO RESPONSE]".`;
       }
 
       const triggerPayloadText = executionMeta.triggerPayload