neoagent 2.1.16-beta.0 → 2.1.16

package/lib/manager.js

@@ -25,9 +25,11 @@ const {
   parseReleaseChannel,
   getReleaseChannelBranch,
   getReleaseChannelDistTag,
-  getReleaseChannelLabel,
   readConfiguredReleaseChannel,
   writeReleaseChannelToEnvFile,
+  describeReleaseChannelPolicy,
+  choosePreferredBranchForChannel,
+  choosePreferredNpmTagForChannel,
 } = require('../runtime/release_channel');
 
 const APP_NAME = 'NeoAgent';
@@ -197,8 +199,7 @@ function currentReleaseChannel() {
 }
 
 function releaseChannelSummary(channel) {
-  const normalized = parseReleaseChannel(channel) || currentReleaseChannel();
-  return `${getReleaseChannelLabel(normalized)} (branch ${getReleaseChannelBranch(normalized)}, npm ${getReleaseChannelDistTag(normalized)})`;
+  return describeReleaseChannelPolicy(parseReleaseChannel(channel) || currentReleaseChannel());
 }
 
 function gitWorkingTreeDirty() {
@@ -214,6 +215,62 @@ function gitRemoteBranchExists(branch) {
   return runQuiet('git', ['ls-remote', '--exit-code', '--heads', 'origin', branch]).status === 0;
 }
 
+function latestGitTagVersion(pattern) {
+  const res = runQuiet('git', ['tag', '--list', pattern, '--sort=-v:refname']);
+  if (res.status !== 0) return null;
+  const tag = res.stdout
+    .split('\n')
+    .map((value) => value.trim())
+    .find(Boolean);
+  return tag ? tag.replace(/^v/, '') : null;
+}
+
+function resolvePreferredGitBranch(channel) {
+  const normalized = parseReleaseChannel(channel) || currentReleaseChannel();
+  if (normalized === 'stable') {
+    return getReleaseChannelBranch(normalized);
+  }
+
+  const stableVersion = latestGitTagVersion('v[0-9]*.[0-9]*.[0-9]*');
+  const betaVersion = latestGitTagVersion('v[0-9]*.[0-9]*.[0-9]*-beta.*');
+  const preferred = choosePreferredBranchForChannel(normalized, {
+    stable: stableVersion,
+    beta: betaVersion,
+  });
+
+  if (preferred === 'beta' && !gitRemoteBranchExists('beta')) {
+    return 'main';
+  }
+  return preferred;
+}
+
+function resolvePreferredNpmTag(channel) {
+  const normalized = parseReleaseChannel(channel) || currentReleaseChannel();
+  if (normalized === 'stable') {
+    return getReleaseChannelDistTag(normalized);
+  }
+
+  const distTags = {};
+  const tagsRes = runQuiet('npm', ['view', 'neoagent', 'dist-tags', '--json'], {
+    env: withInstallEnv(),
+  });
+  if (tagsRes.status === 0) {
+    try {
+      const parsed = JSON.parse(tagsRes.stdout || '{}');
+      if (parsed && typeof parsed === 'object') {
+        Object.assign(distTags, parsed);
+      }
+    } catch {
+      // Ignore parse failures and fall back to the beta tag.
+    }
+  }
+
+  return choosePreferredNpmTagForChannel(normalized, {
+    latest: distTags.latest,
+    beta: distTags.beta,
+  });
+}
+
 function ensureGitBranchForReleaseChannel(targetBranch) {
   const branchRes = runQuiet('git', ['rev-parse', '--abbrev-ref', 'HEAD']);
   const currentBranch = branchRes.status === 0 ? branchRes.stdout.trim() : '';
@@ -692,15 +749,15 @@ function cmdUpdate(args = []) {
     process.env.NEOAGENT_RELEASE_CHANNEL = releaseChannel;
     logOk(`Release channel set to ${releaseChannelSummary(releaseChannel)}`);
   }
-  const targetBranch = getReleaseChannelBranch(releaseChannel);
-  const npmTag = getReleaseChannelDistTag(releaseChannel);
   const versionBefore = currentInstalledVersionLabel();
   let versionAfter = versionBefore;
 
   if (fs.existsSync(path.join(APP_DIR, '.git')) && commandExists('git')) {
     const current = runQuiet('git', ['rev-parse', '--short', 'HEAD']);
 
-    runOrThrow('git', ['fetch', 'origin', targetBranch]);
+    runOrThrow('git', ['fetch', 'origin', '--tags']);
+    const targetBranch = resolvePreferredGitBranch(releaseChannel);
+    logInfo(`Using git branch ${targetBranch} for the ${releaseChannel} channel.`);
     ensureGitBranchForReleaseChannel(targetBranch);
     runOrThrow('git', ['pull', '--rebase', '--autostash', 'origin', targetBranch]);
 
@@ -714,6 +771,7 @@ function cmdUpdate(args = []) {
       buildBundledWebClientIfPossible();
     }
   } else {
+    const npmTag = resolvePreferredNpmTag(releaseChannel);
     logWarn(`No git repo detected; attempting npm global update from ${npmTag}.`);
     if (commandExists('npm')) {
       try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "2.1.16-beta.0",
+  "version": "2.1.16",
   "description": "Proactive personal AI agent with no limits",
   "license": "MIT",
   "main": "server/index.js",

package/runtime/release_channel.js

@@ -14,6 +14,14 @@ const RELEASE_CHANNEL_DIST_TAGS = Object.freeze({
   stable: 'latest',
   beta: 'beta',
 });
+const RELEASE_CHANNEL_BRANCH_POLICIES = Object.freeze({
+  stable: 'main only',
+  beta: 'newest of beta or main',
+});
+const RELEASE_CHANNEL_NPM_POLICIES = Object.freeze({
+  stable: 'latest only',
+  beta: 'newest of beta or latest',
+});
 
 function parseEnv(raw) {
   const map = new Map();
@@ -62,6 +70,116 @@ function getReleaseChannelLabel(channel) {
   return normalizeReleaseChannel(channel) === 'beta' ? 'Beta' : 'Stable';
 }
 
+function parseSemver(version) {
+  const match = String(version || '')
+    .trim()
+    .replace(/^v/, '')
+    .match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
+  if (!match) {
+    return null;
+  }
+
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ? match[4].split('.') : [],
+    raw: match[0],
+  };
+}
+
+function comparePrereleasePart(left, right) {
+  const leftNumeric = /^\d+$/.test(left);
+  const rightNumeric = /^\d+$/.test(right);
+
+  if (leftNumeric && rightNumeric) {
+    return Number(left) - Number(right);
+  }
+  if (leftNumeric) return -1;
+  if (rightNumeric) return 1;
+  return left.localeCompare(right);
+}
+
+function compareVersions(leftVersion, rightVersion) {
+  const left = parseSemver(leftVersion);
+  const right = parseSemver(rightVersion);
+
+  if (!left && !right) return 0;
+  if (!left) return -1;
+  if (!right) return 1;
+
+  for (const key of ['major', 'minor', 'patch']) {
+    if (left[key] !== right[key]) {
+      return left[key] - right[key];
+    }
+  }
+
+  const leftPre = left.prerelease;
+  const rightPre = right.prerelease;
+  if (leftPre.length === 0 && rightPre.length === 0) return 0;
+  if (leftPre.length === 0) return 1;
+  if (rightPre.length === 0) return -1;
+
+  const length = Math.max(leftPre.length, rightPre.length);
+  for (let i = 0; i < length; i++) {
+    const leftPart = leftPre[i];
+    const rightPart = rightPre[i];
+    if (leftPart == null) return -1;
+    if (rightPart == null) return 1;
+    const diff = comparePrereleasePart(leftPart, rightPart);
+    if (diff !== 0) {
+      return diff;
+    }
+  }
+
+  return 0;
+}
+
+function maxVersion(leftVersion, rightVersion) {
+  return compareVersions(leftVersion, rightVersion) >= 0 ? leftVersion : rightVersion;
+}
+
+function describeReleaseChannelPolicy(channel) {
+  const normalized = normalizeReleaseChannel(channel);
+  return `${getReleaseChannelLabel(normalized)} (git ${RELEASE_CHANNEL_BRANCH_POLICIES[normalized]}, npm ${RELEASE_CHANNEL_NPM_POLICIES[normalized]})`;
+}
+
+function getReleaseChannelBranchPolicy(channel) {
+  return RELEASE_CHANNEL_BRANCH_POLICIES[normalizeReleaseChannel(channel)];
+}
+
+function getReleaseChannelNpmPolicy(channel) {
+  return RELEASE_CHANNEL_NPM_POLICIES[normalizeReleaseChannel(channel)];
+}
+
+function choosePreferredBranchForChannel(channel, versions = {}) {
+  const normalized = normalizeReleaseChannel(channel);
+  if (normalized === 'stable') {
+    return 'main';
+  }
+
+  const stableVersion = versions.stable;
+  const betaVersion = versions.beta;
+  if (compareVersions(betaVersion, stableVersion) > 0) {
+    return 'beta';
+  }
+  return 'main';
+}
+
+function choosePreferredNpmTagForChannel(channel, versions = {}) {
+  const normalized = normalizeReleaseChannel(channel);
+  if (normalized === 'stable') {
+    return 'latest';
+  }
+
+  const stableVersion = versions.latest;
+  const betaVersion = versions.beta;
+  if (compareVersions(betaVersion, stableVersion) > 0) {
+    return 'beta';
+  }
+  return 'latest';
+}
+
 function readReleaseChannelFromRaw(raw) {
   const env = parseEnv(raw);
   return normalizeReleaseChannel(env.get(RELEASE_CHANNEL_ENV_KEY));
@@ -116,6 +234,14 @@ module.exports = {
   getReleaseChannelBranch,
   getReleaseChannelDistTag,
   getReleaseChannelLabel,
+  parseSemver,
+  compareVersions,
+  maxVersion,
+  describeReleaseChannelPolicy,
+  getReleaseChannelBranchPolicy,
+  getReleaseChannelNpmPolicy,
+  choosePreferredBranchForChannel,
+  choosePreferredNpmTagForChannel,
   readReleaseChannelFromRaw,
   readReleaseChannelFromEnvFile,
   readConfiguredReleaseChannel,

package/server/db/database.js

@@ -40,6 +40,7 @@ db.exec(`
     total_tokens INTEGER DEFAULT 0,
     prompt_metrics TEXT,
     error TEXT,
+    final_response TEXT,
     created_at TEXT DEFAULT (datetime('now')),
     updated_at TEXT DEFAULT (datetime('now')),
     completed_at TEXT,
@@ -389,6 +390,7 @@ for (const col of [
   "ALTER TABLE scheduled_tasks ADD COLUMN run_at TEXT",
   "ALTER TABLE scheduled_tasks ADD COLUMN one_time INTEGER DEFAULT 0",
   "ALTER TABLE agent_runs ADD COLUMN prompt_metrics TEXT",
+  "ALTER TABLE agent_runs ADD COLUMN final_response TEXT",
   "ALTER TABLE conversations ADD COLUMN summary TEXT",
   "ALTER TABLE conversations ADD COLUMN summary_message_count INTEGER DEFAULT 0",
   "ALTER TABLE conversations ADD COLUMN last_summary TEXT",

package/server/public/flutter_bootstrap.js

@@ -37,6 +37,6 @@ _flutter.buildConfig = {"engineRevision":"052f31d115eceda8cbff1b3481fcde4330c4ae
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "1956345956" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
+    serviceWorkerVersion: "4059413374" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
   }
 });

package/server/routes/agents.js

@@ -94,11 +94,23 @@ router.get('/:id/steps', (req, res) => {
   if (!run) return res.status(404).json({ error: 'Run not found' });
 
   const steps = db.prepare('SELECT * FROM agent_steps WHERE run_id = ? ORDER BY step_index ASC').all(run.id);
-  const response = db.prepare(
+  const historyResponse = db.prepare(
     `SELECT content FROM conversation_history WHERE user_id = ? AND agent_run_id = ? AND role = 'assistant' ORDER BY created_at DESC LIMIT 1`
   ).get(req.session.userId, run.id);
-
-  res.json({ run, steps, response: response?.content || null });
+  const sentMessages = db.prepare(
+    `SELECT content FROM messages WHERE user_id = ? AND run_id = ? AND role = 'assistant' ORDER BY created_at ASC, id ASC`
+  ).all(req.session.userId, run.id);
+  const sentResponse = sentMessages
+    .map((row) => row?.content?.toString().trim() || '')
+    .filter(Boolean)
+    .join('\n\n');
+  const response =
+    sentResponse
+    || historyResponse?.content
+    || run.final_response
+    || null;
+
+  res.json({ run, steps, response });
 });
 
 // Abort a run

package/server/routes/settings.js

@@ -1,17 +1,19 @@
 const express = require('express');
-const fs = require('fs');
-const path = require('path');
 const router = express.Router();
 const db = require('../db/database');
 const { requireAuth } = require('../middleware/auth');
 const { normalizeWhatsAppWhitelist } = require('../utils/whatsapp');
 const { getVersionInfo } = require('../utils/version');
-const { UPDATE_STATUS_FILE, APP_DIR } = require('../../runtime/paths');
+const { APP_DIR } = require('../../runtime/paths');
+const {
+  readUpdateStatus,
+  writeUpdateStatusFile: writeUpdateStatus,
+} = require('../utils/update_status');
 const {
   parseReleaseChannel,
-  getReleaseChannelBranch,
-  getReleaseChannelDistTag,
   writeReleaseChannelToEnvFile,
+  getReleaseChannelBranchPolicy,
+  getReleaseChannelNpmPolicy,
 } = require('../../runtime/release_channel');
 const {
   createDefaultAiSettings,
@@ -21,36 +23,6 @@ const {
 
 router.use(requireAuth);
 
-function readUpdateStatus() {
-  try {
-    return JSON.parse(fs.readFileSync(UPDATE_STATUS_FILE, 'utf8'));
-  } catch {
-    return {
-      state: 'idle',
-      progress: 0,
-      phase: 'idle',
-      message: 'No update running',
-      startedAt: null,
-      completedAt: null,
-      versionBefore: null,
-      versionAfter: null,
-      changelog: [],
-      logs: []
-    };
-  }
-}
-
-function writeUpdateStatus(patch) {
-  const next = {
-    ...readUpdateStatus(),
-    ...patch,
-    updatedAt: new Date().toISOString()
-  };
-  fs.mkdirSync(path.dirname(UPDATE_STATUS_FILE), { recursive: true });
-  fs.writeFileSync(UPDATE_STATUS_FILE, JSON.stringify(next, null, 2));
-  return next;
-}
-
 function canApplyGlobalBrowserSetting(userId) {
   const users = db.prepare('SELECT id FROM users ORDER BY id ASC').all();
   return users.length <= 1 || users[0]?.id === userId;
@@ -288,6 +260,12 @@ router.post('/update', (req, res) => {
     return res.status(409).json({ success: false, error: 'An update is already running' });
   }
   console.log('[Settings] Triggering update-runner...');
+  const child = spawn(process.execPath, ['scripts/update-runner.js'], {
+    detached: true,
+    stdio: 'ignore',
+    cwd: APP_DIR
+  });
+
   writeUpdateStatus({
     state: 'running',
     progress: 1,
@@ -297,24 +275,19 @@ router.post('/update', (req, res) => {
     completedAt: null,
     versionBefore: null,
     versionAfter: null,
+    runnerPid: child.pid,
     changelog: [],
     logs: []
   });
 
-  // Spawn detached runner so status survives server restarts.
-  const child = spawn(process.execPath, ['scripts/update-runner.js'], {
-    detached: true,
-    stdio: 'ignore',
-    cwd: APP_DIR
-  });
-
   child.once('error', (error) => {
     writeUpdateStatus({
       state: 'failed',
       progress: 100,
       phase: 'failed',
       message: `Failed to launch update job: ${error.message}`,
-      completedAt: new Date().toISOString()
+      completedAt: new Date().toISOString(),
+      runnerPid: null,
     });
   });
 
@@ -338,8 +311,8 @@ router.put('/update/channel', (req, res) => {
   res.json({
     success: true,
     releaseChannel,
-    targetBranch: getReleaseChannelBranch(releaseChannel),
-    npmDistTag: getReleaseChannelDistTag(releaseChannel),
+    targetBranch: getReleaseChannelBranchPolicy(releaseChannel),
+    npmDistTag: getReleaseChannelNpmPolicy(releaseChannel),
   });
 });
 
@@ -354,9 +327,9 @@ router.get('/update/status', (req, res) => {
     gitVersion: version.gitVersion,
     gitSha: version.gitSha,
     gitBranch: version.gitBranch,
-    releaseChannel: version.releaseChannel,
-    targetBranch: version.targetBranch,
-    npmDistTag: version.npmDistTag,
+    releaseChannel: status.releaseChannel || version.releaseChannel,
+    targetBranch: status.targetBranch || version.targetBranch,
+    npmDistTag: status.npmDistTag || version.npmDistTag,
   });
 });
 

package/server/services/ai/engine.js

@@ -138,6 +138,22 @@ function normalizeOutgoingMessage(content) {
     .trim();
 }
 
+function joinSentMessages(messages = []) {
+  if (!Array.isArray(messages)) return '';
+  return messages
+    .map((message) => String(message || '').trim())
+    .filter(Boolean)
+    .join('\n\n');
+}
+
+function buildForcedFinalReplyPrompt(triggerSource) {
+  if (triggerSource === 'messaging') {
+    return 'Tool work is finished. Write the user-visible reply that should be sent back now. Do not call tools. Do not use [NO RESPONSE] unless the user explicitly asked for silence or no confirmation.';
+  }
+
+  return 'Tool work is finished. Write the final user-facing reply now. Do not call tools.';
+}
+
 function clampRunContext(text, maxChars) {
   const value = normalizeOutgoingMessage(text);
   if (!value) return '';
@@ -458,6 +474,7 @@ class AgentEngine {
       aborted: false,
       messagingSent: false,
       lastSentMessage: '',
+      sentMessages: [],
       triggerType,
       triggerSource,
       startedAt: Date.now(),
@@ -506,7 +523,6 @@ class AgentEngine {
     let totalTokens = 0;
     let lastContent = '';
     let stepIndex = 0;
-    let forcedFinalResponse = false;
     let promptMetrics = {};
 
     try {
@@ -766,12 +782,17 @@ class AgentEngine {
 
       if ((iteration >= maxIterations && messages[messages.length - 1]?.role === 'tool')
         || (iteration < maxIterations && stepIndex > 0 && !lastContent.trim() && messages[messages.length - 1]?.role !== 'tool')) {
-        const finalResponse = await provider.chat(sanitizeConversationMessages(messages), [], {
+        const finalResponse = await provider.chat(sanitizeConversationMessages([
+          ...messages,
+          {
+            role: 'system',
+            content: buildForcedFinalReplyPrompt(triggerSource)
+          }
+        ]), [], {
           model,
           reasoningEffort: this.getReasoningEffort(providerName, options)
         });
         lastContent = sanitizeModelOutput(finalResponse.content || '', { model });
-        forcedFinalResponse = true;
 
         const finalAssistantMessage = { role: 'assistant', content: lastContent };
         if (finalResponse.providerContentBlocks?.length) {
@@ -785,8 +806,18 @@ class AgentEngine {
         totalTokens += finalResponse.usage?.totalTokens || 0;
       }
 
-      db.prepare('UPDATE agent_runs SET status = ?, total_tokens = ?, updated_at = datetime(\'now\'), completed_at = datetime(\'now\') WHERE id = ?')
-        .run('completed', totalTokens, runId);
+      const runMeta = this.activeRuns.get(runId);
+      const messagingSent = runMeta?.messagingSent || false;
+      const sentMessageText = joinSentMessages(runMeta?.sentMessages);
+      const finalResponseText = lastContent.trim() ? lastContent : sentMessageText;
+      const lastSentMessage = normalizeOutgoingMessage(
+        runMeta?.lastSentMessage
+        || (Array.isArray(runMeta?.sentMessages) ? runMeta.sentMessages[runMeta.sentMessages.length - 1] : '')
+        || ''
+      );
+
+      db.prepare('UPDATE agent_runs SET status = ?, total_tokens = ?, final_response = ?, updated_at = datetime(\'now\'), completed_at = datetime(\'now\') WHERE id = ?')
+        .run('completed', totalTokens, finalResponseText || null, runId);
 
       if (conversationId) {
         db.prepare('UPDATE conversations SET total_tokens = total_tokens + ?, updated_at = datetime(\'now\') WHERE id = ?')
@@ -805,13 +836,10 @@ class AgentEngine {
         triggerSource,
         runTitle,
         userMessage,
-        lastContent,
+        lastContent: finalResponseText,
         stepIndex
       });
 
-      const runMeta = this.activeRuns.get(runId);
-      const messagingSent = runMeta?.messagingSent || false;
-      const lastSentMessage = normalizeOutgoingMessage(runMeta?.lastSentMessage || '');
       this.activeRuns.delete(runId);
       this.emit(userId, 'run:complete', { runId, content: lastContent, totalTokens, iterations: iteration, triggerSource });
 
@@ -836,7 +864,7 @@ class AgentEngine {
                   await manager.sendTyping(userId, options.source, options.chatId, true).catch(() => { });
                   await new Promise((resolve) => setTimeout(resolve, delay));
                 }
-                await manager.sendMessage(userId, options.source, options.chatId, chunks[i]).catch((err) =>
+                await manager.sendMessage(userId, options.source, options.chatId, chunks[i], { runId }).catch((err) =>
                   console.error('[Engine] Auto-reply fallback failed:', err.message)
                 );
               }

package/server/services/ai/tools.js

@@ -457,7 +457,7 @@ function getAvailableTools(app, options = {}) {
         },
         {
             name: 'send_message',
-            description: 'Send a message on a connected messaging platform. Supports WhatsApp (text/media), Telnyx Voice (phone calls — TTS), Discord, and Telegram. For WhatsApp: use media_path to attach files. To stay silent, send content "[NO RESPONSE]". For Telnyx Voice: always reply with plain spoken text; never use [NO RESPONSE] or markdown.',
+            description: 'Send a message on a connected messaging platform. Supports WhatsApp (text/media), Telnyx Voice (phone calls — TTS), Discord, and Telegram. For WhatsApp: use media_path to attach files. Use content "[NO RESPONSE]" only when the user explicitly asked for silence or no reply. For Telnyx Voice: always reply with plain spoken text; never use [NO RESPONSE] or markdown.',
             parameters: {
                 type: 'object',
                 properties: {
@@ -1113,12 +1113,18 @@ async function executeTool(toolName, args, context, engine) {
         case 'send_message': {
             const manager = msg();
             if (!manager) return { error: 'Messaging not available' };
-            const sendResult = await manager.sendMessage(userId, args.platform, args.to, args.content, args.media_path);
+            const sendResult = await manager.sendMessage(userId, args.platform, args.to, args.content, {
+                mediaPath: args.media_path,
+                runId
+            });
             // Track that the agent explicitly sent a message during this run
             const runState = runId ? engine.activeRuns.get(runId) : null;
             if (runState && args.content !== '[NO RESPONSE]') {
                 runState.messagingSent = true;
                 runState.lastSentMessage = args.content || '';
+                if (Array.isArray(runState.sentMessages)) {
+                    runState.sentMessages.push(args.content || '');
+                }
             }
             return sendResult;
         }
@@ -1369,7 +1375,9 @@ async function executeTool(toolName, args, context, engine) {
                     }
 
                     try {
-                        const sendResult = await manager.sendMessage(userId, target.platform, target.to, message);
+                        const sendResult = await manager.sendMessage(userId, target.platform, target.to, message, {
+                            runId
+                        });
                         if (taskId && taskConfig && (taskConfig.notifyPlatform !== target.platform || taskConfig.notifyTo !== target.to)) {
                             taskConfig.notifyPlatform = target.platform;
                             taskConfig.notifyTo = target.to;
@@ -1381,6 +1389,9 @@ async function executeTool(toolName, args, context, engine) {
                         if (runState) {
                             runState.messagingSent = true;
                             runState.lastSentMessage = message;
+                            if (Array.isArray(runState.sentMessages)) {
+                                runState.sentMessages.push(message);
+                            }
                         }
                         return {
                             sent: true,

package/server/services/messaging/automation.js

@@ -200,7 +200,7 @@ function buildIncomingPrompt(msg) {
     return `You are on a live phone call. The caller (${msg.senderName || msg.sender}) said:\n<caller_speech>\n${msg.content}\n</caller_speech>\n\nRespond via send_message with platform="telnyx" and to="${msg.chatId}".`;
   }
 
-  return `You received a ${msg.platform} message from ${msg.senderName || msg.sender} (chat: ${msg.chatId}):\n<external_message>\n${msg.content}\n</external_message>${mediaNote}${discordContext}${sttNote}\n\nReply via send_message with platform="${msg.platform}" and to="${msg.chatId}".`;
+  return `You received a ${msg.platform} message from ${msg.senderName || msg.sender} (chat: ${msg.chatId}):\n<external_message>\n${msg.content}\n</external_message>${mediaNote}${discordContext}${sttNote}\n\nReply via send_message with platform="${msg.platform}" and to="${msg.chatId}". Send at least one user-visible reply before you finish. Do not use [NO RESPONSE] unless the user explicitly asked for silence or no confirmation.`;
 }
 
 async function isAllowedMessagingSender({ io, userId, msg }) {

package/server/services/messaging/manager.js

@@ -164,11 +164,18 @@ class MessagingManager {
     return { status: 'disconnected' };
   }
 
-  async sendMessage(userId, platformName, to, content, mediaPath) {
+  async sendMessage(userId, platformName, to, content, mediaPathOrOptions) {
     const key = `${userId}:${platformName}`;
     const platform = this.platforms.get(key);
     if (!platform) throw new Error(`Platform ${platformName} not connected`);
 
+    const sendOptions =
+      mediaPathOrOptions && typeof mediaPathOrOptions === 'object' && !Array.isArray(mediaPathOrOptions)
+        ? mediaPathOrOptions
+        : { mediaPath: mediaPathOrOptions };
+    const mediaPath = sendOptions.mediaPath || null;
+    const runId = sendOptions.runId || null;
+
     // Sentinel: agent can choose not to reply by sending [NO RESPONSE]
     if (!mediaPath && typeof content === 'string' && content.trim().toUpperCase() === '[NO RESPONSE]') {
       return { success: true, suppressed: true };
@@ -176,15 +183,16 @@ class MessagingManager {
 
     const result = await platform.sendMessage(to, content, { mediaPath });
 
-    db.prepare('INSERT INTO messages (user_id, role, content, platform, platform_chat_id, media_path) VALUES (?, ?, ?, ?, ?, ?)')
-      .run(userId, 'assistant', content, platformName, to, mediaPath || null);
+    db.prepare('INSERT INTO messages (user_id, run_id, role, content, platform, platform_chat_id, media_path) VALUES (?, ?, ?, ?, ?, ?, ?)')
+      .run(userId, runId, 'assistant', content, platformName, to, mediaPath);
 
     // Notify the web UI so the sent message appears in chat
     this.io.to(`user:${userId}`).emit('messaging:sent', {
       platform: platformName,
       to,
       content,
-      mediaPath: mediaPath || null
+      mediaPath,
+      runId
     });
 
     return { success: true, result };

package/server/utils/update_status.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { UPDATE_STATUS_FILE } = require('../../runtime/paths');
+
+const DEFAULT_UPDATE_STATUS = Object.freeze({
+  state: 'idle',
+  progress: 0,
+  phase: 'idle',
+  message: 'No update running',
+  startedAt: null,
+  completedAt: null,
+  versionBefore: null,
+  versionAfter: null,
+  runnerPid: null,
+  changelog: [],
+  logs: [],
+});
+
+function isProcessAlive(pid) {
+  const numericPid = Number(pid);
+  if (!Number.isInteger(numericPid) || numericPid <= 0) {
+    return false;
+  }
+
+  try {
+    process.kill(numericPid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function readUpdateStatusFile(filePath = UPDATE_STATUS_FILE) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return { ...DEFAULT_UPDATE_STATUS };
+  }
+}
+
+function normalizeUpdateStatus(status) {
+  const next = {
+    ...DEFAULT_UPDATE_STATUS,
+    ...(status || {}),
+  };
+
+  if (next.state === 'running' && !isProcessAlive(next.runnerPid)) {
+    return {
+      ...next,
+      state: 'failed',
+      progress: 100,
+      phase: 'failed',
+      message: 'Previous update job stopped unexpectedly. You can try the update again.',
+      completedAt: next.completedAt || new Date().toISOString(),
+      runnerPid: null,
+    };
+  }
+
+  return next;
+}
+
+function writeUpdateStatusFile(patch, filePath = UPDATE_STATUS_FILE) {
+  const current = normalizeUpdateStatus(readUpdateStatusFile(filePath));
+  const next = normalizeUpdateStatus({
+    ...current,
+    ...patch,
+    updatedAt: new Date().toISOString(),
+  });
+
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(next, null, 2));
+  return next;
+}
+
+function readUpdateStatus(filePath = UPDATE_STATUS_FILE) {
+  const raw = readUpdateStatusFile(filePath);
+  const normalized = normalizeUpdateStatus(raw);
+  if (JSON.stringify(raw) !== JSON.stringify(normalized)) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(normalized, null, 2));
+  }
+  return normalized;
+}
+
+module.exports = {
+  DEFAULT_UPDATE_STATUS,
+  isProcessAlive,
+  normalizeUpdateStatus,
+  readUpdateStatus,
+  writeUpdateStatusFile,
+};

package/server/utils/version.js

@@ -5,9 +5,9 @@ const path = require('path');
 const { execSync } = require('child_process');
 const { APP_DIR } = require('../../runtime/paths');
 const {
-  getReleaseChannelBranch,
-  getReleaseChannelDistTag,
   readConfiguredReleaseChannel,
+  getReleaseChannelBranchPolicy,
+  getReleaseChannelNpmPolicy,
 } = require('../../runtime/release_channel');
 
 const PACKAGE_JSON_PATH = path.join(APP_DIR, 'package.json');
@@ -67,8 +67,8 @@ function getVersionInfo() {
     gitSha,
     installedVersion: packageVersion,
     releaseChannel,
-    targetBranch: getReleaseChannelBranch(releaseChannel),
-    npmDistTag: getReleaseChannelDistTag(releaseChannel),
+    targetBranch: getReleaseChannelBranchPolicy(releaseChannel),
+    npmDistTag: getReleaseChannelNpmPolicy(releaseChannel),
   };
 }