vellum 0.0.16 → 0.2.0

package/src/config/bundled-skills/messaging/tools/gmail-unsubscribe.ts

@@ -0,0 +1,84 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { withValidToken } from '../../../../security/token-manager.js';
+import { getMessagingProvider } from '../../../../messaging/registry.js';
+import { getMessage, sendMessage } from '../../../../messaging/providers/gmail/client.js';
+import { isPrivateOrLocalHost, resolveHostAddresses, resolveRequestAddress } from '../../../../tools/network/url-safety.js';
+import { ok, err, pinnedHttpsRequest } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const messageId = input.message_id as string;
+
+  if (!messageId) {
+    return err('message_id is required.');
+  }
+
+  try {
+    const provider = getMessagingProvider('gmail');
+    return withValidToken(provider.credentialService, async (token) => {
+      const message = await getMessage(token, messageId, 'metadata', ['List-Unsubscribe', 'List-Unsubscribe-Post']);
+      const headers = message.payload?.headers ?? [];
+      const unsubHeader = headers.find((h) => h.name.toLowerCase() === 'list-unsubscribe')?.value;
+
+      if (!unsubHeader) {
+        return err('No List-Unsubscribe header found. Manual unsubscribe may be required.');
+      }
+
+      const httpsMatch = unsubHeader.match(/<(https:\/\/[^>]+)>/);
+      const mailtoMatch = unsubHeader.match(/<mailto:([^>]+)>/);
+      const postHeader = headers.find((h) => h.name.toLowerCase() === 'list-unsubscribe-post')?.value;
+
+      if (httpsMatch) {
+        const url = httpsMatch[1];
+        let parsed: URL;
+        let validatedAddresses: string[];
+        try {
+          parsed = new URL(url);
+          if (parsed.protocol !== 'https:') {
+            return err('Unsubscribe URL must use HTTPS.');
+          }
+          if (isPrivateOrLocalHost(parsed.hostname)) {
+            return err('Unsubscribe URL points to a private or local address.');
+          }
+          const { addresses, blockedAddress } = await resolveRequestAddress(parsed.hostname, resolveHostAddresses, false);
+          if (blockedAddress) {
+            return err('Unsubscribe URL resolves to a private or local address.');
+          }
+          if (addresses.length === 0) {
+            return err('Unable to resolve unsubscribe URL hostname.');
+          }
+          validatedAddresses = addresses;
+        } catch {
+          return err('Invalid unsubscribe URL.');
+        }
+
+        const method = postHeader ? 'POST' : 'GET';
+        const reqOpts = postHeader
+          ? { method: 'POST' as const, headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, body: postHeader }
+          : undefined;
+
+        let lastStatus = 0;
+        for (const address of validatedAddresses) {
+          try {
+            lastStatus = await pinnedHttpsRequest(parsed, address, reqOpts);
+            if (lastStatus >= 200 && lastStatus < 400) {
+              return ok(`Successfully unsubscribed via HTTPS ${method}.`);
+            }
+          } catch {
+            continue;
+          }
+        }
+        return err(`Unsubscribe request failed: ${lastStatus}`);
+      }
+
+      if (mailtoMatch) {
+        const mailtoAddr = mailtoMatch[1].split('?')[0];
+        await sendMessage(token, mailtoAddr, 'Unsubscribe', 'Unsubscribe');
+        return ok(`Unsubscribe email sent to ${mailtoAddr}.`);
+      }
+
+      return err('No supported unsubscribe method found (requires https: or mailto: URL).');
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/messaging/tools/messaging-analyze-activity.ts

@@ -0,0 +1,18 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { classifyActivity } from '../../../../messaging/activity-analyzer.js';
+import { resolveProvider, withProviderToken, ok, err } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const platform = input.platform as string | undefined;
+
+  try {
+    const provider = resolveProvider(platform);
+    return withProviderToken(provider, async (token) => {
+      const conversations = await provider.listConversations(token);
+      const summary = classifyActivity(conversations, provider.id);
+      return ok(JSON.stringify(summary, null, 2));
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/messaging/tools/messaging-analyze-style.ts

@@ -0,0 +1,124 @@
+import { and, eq } from 'drizzle-orm';
+import { v4 as uuid } from 'uuid';
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { getDb } from '../../../../memory/db.js';
+import { computeMemoryFingerprint } from '../../../../memory/fingerprint.js';
+import { memoryItems } from '../../../../memory/schema.js';
+import { enqueueMemoryJob } from '../../../../memory/jobs-store.js';
+import { extractStylePatterns } from '../../../../messaging/style-analyzer.js';
+import { resolveProvider, withProviderToken, ok, err } from './shared.js';
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(max, Math.max(min, value));
+}
+
+function upsertMemoryItem(opts: {
+  kind: string;
+  subject: string;
+  statement: string;
+  importance: number;
+  scopeId: string;
+}): void {
+  const db = getDb();
+  const now = Date.now();
+  const fingerprint = computeMemoryFingerprint(opts.scopeId, opts.kind, opts.subject, opts.statement);
+
+  const existing = db
+    .select()
+    .from(memoryItems)
+    .where(and(eq(memoryItems.fingerprint, fingerprint), eq(memoryItems.scopeId, opts.scopeId)))
+    .get();
+
+  if (existing) {
+    db.update(memoryItems)
+      .set({
+        statement: opts.statement,
+        status: 'active',
+        importance: Math.max(existing.importance ?? 0, opts.importance),
+        lastSeenAt: now,
+        verificationState: 'assistant_inferred',
+      })
+      .where(eq(memoryItems.id, existing.id))
+      .run();
+    enqueueMemoryJob('embed_item', { itemId: existing.id });
+  } else {
+    const id = uuid();
+    db.insert(memoryItems).values({
+      id,
+      kind: opts.kind,
+      subject: opts.subject,
+      statement: opts.statement,
+      status: 'active',
+      confidence: 0.8,
+      importance: opts.importance,
+      fingerprint,
+      verificationState: 'assistant_inferred',
+      scopeId: opts.scopeId,
+      firstSeenAt: now,
+      lastSeenAt: now,
+      lastUsedAt: null,
+    }).run();
+    enqueueMemoryJob('embed_item', { itemId: id });
+  }
+}
+
+export async function run(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
+  const platform = input.platform as string | undefined;
+  const maxMessages = Math.min(Math.max((input.max_messages as number) ?? 50, 1), 100);
+  const queryFilter = input.query_filter as string | undefined;
+
+  try {
+    const provider = resolveProvider(platform);
+    return withProviderToken(provider, async (token) => {
+      // Search for sent messages using the platform's search
+      const query = queryFilter ?? (provider.id === 'gmail' ? 'in:sent' : 'from:me');
+      const searchResult = await provider.search(token, query, { count: maxMessages });
+
+      if (searchResult.messages.length === 0) {
+        return err('No sent messages found. Send some messages first, then try again.');
+      }
+
+      const result = await extractStylePatterns(searchResult.messages);
+
+      if (result.stylePatterns.length === 0) {
+        return err('No style patterns were extracted. Try with more messages.');
+      }
+
+      const scopeId = context.memoryScopeId ?? 'default';
+      let savedCount = 0;
+
+      for (const pattern of result.stylePatterns) {
+        const subject = `${provider.id} writing style: ${pattern.aspect}`;
+        const importance = clamp(pattern.importance ?? 0.65, 0.55, 0.85);
+        upsertMemoryItem({ kind: 'style', subject, statement: pattern.summary, importance, scopeId });
+        savedCount++;
+      }
+
+      for (const contact of result.contactObservations) {
+        if (!contact.name || !contact.toneNote) continue;
+        const subject = `${provider.id} relationship: ${contact.name}`;
+        upsertMemoryItem({
+          kind: 'relationship',
+          subject,
+          statement: `${contact.name} (${contact.email}): ${contact.toneNote}`.slice(0, 500),
+          importance: 0.6,
+          scopeId,
+        });
+        savedCount++;
+      }
+
+      const aspects = result.stylePatterns.map((p) => p.aspect).join(', ');
+      const contactCount = result.contactObservations.length;
+      const summary = [
+        `Analyzed ${searchResult.messages.length} messages on ${provider.displayName}.`,
+        `Extracted ${result.stylePatterns.length} style patterns (${aspects}).`,
+        contactCount > 0 ? `Noted ${contactCount} recurring contact relationship(s).` : '',
+        `Saved ${savedCount} memory items. Future drafts will automatically reflect your writing style.`,
+      ].filter(Boolean).join(' ');
+
+      return ok(summary);
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/messaging/tools/messaging-auth-test.ts

@@ -0,0 +1,16 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { resolveProvider, withProviderToken, ok, err } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const platform = input.platform as string | undefined;
+
+  try {
+    const provider = resolveProvider(platform);
+    return withProviderToken(provider, async (token) => {
+      const info = await provider.testConnection(token);
+      return ok(JSON.stringify(info, null, 2));
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/messaging/tools/messaging-draft.ts

@@ -0,0 +1,49 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { createDraft, listDrafts, deleteDraft } from '../../../../messaging/draft-store.js';
+import { ok, err } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const action = input.action as string;
+
+  switch (action) {
+    case 'create': {
+      const platform = input.platform as string | undefined;
+      const conversationId = input.conversation_id as string | undefined;
+      const text = input.text as string | undefined;
+
+      if (!platform) return err('platform is required for creating a draft.');
+      if (!conversationId) return err('conversation_id is required for creating a draft.');
+      if (!text) return err('text is required for creating a draft.');
+
+      const draft = createDraft({
+        platform,
+        conversationId,
+        text,
+        threadId: input.thread_id as string | undefined,
+        subject: input.subject as string | undefined,
+      });
+      return ok(`Draft created (ID: ${draft.id}). Stored locally for review.`);
+    }
+
+    case 'list': {
+      const platform = input.platform as string | undefined;
+      if (!platform) return err('platform is required for listing drafts.');
+      const drafts = listDrafts(platform);
+      if (drafts.length === 0) return ok('No drafts found.');
+      return ok(JSON.stringify(drafts, null, 2));
+    }
+
+    case 'delete': {
+      const draftId = input.draft_id as string | undefined;
+      const platform = input.platform as string | undefined;
+      if (!draftId) return err('draft_id is required for deleting a draft.');
+      if (!platform) return err('platform is required for deleting a draft.');
+      const deleted = deleteDraft(platform, draftId);
+      if (!deleted) return err('Draft not found.');
+      return ok('Draft deleted.');
+    }
+
+    default:
+      return err(`Unknown action "${action}". Use "create", "list", or "delete".`);
+  }
+}

package/src/config/bundled-skills/messaging/tools/messaging-list-conversations.ts

@@ -0,0 +1,21 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { resolveProvider, withProviderToken, ok, err } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const platform = input.platform as string | undefined;
+  const types = input.types as string[] | undefined;
+  const limit = input.limit as number | undefined;
+
+  try {
+    const provider = resolveProvider(platform);
+    return withProviderToken(provider, async (token) => {
+      const conversations = await provider.listConversations(token, {
+        types: types as Array<'channel' | 'dm' | 'group' | 'inbox'> | undefined,
+        limit,
+      });
+      return ok(JSON.stringify(conversations, null, 2));
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/messaging/tools/messaging-mark-read.ts

@@ -0,0 +1,25 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { resolveProvider, withProviderToken, ok, err } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const platform = input.platform as string | undefined;
+  const conversationId = input.conversation_id as string;
+  const messageId = input.message_id as string | undefined;
+
+  if (!conversationId) {
+    return err('conversation_id is required.');
+  }
+
+  try {
+    const provider = resolveProvider(platform);
+    if (!provider.markRead) {
+      return err(`${provider.displayName} does not support marking messages as read.`);
+    }
+    return withProviderToken(provider, async (token) => {
+      await provider.markRead!(token, conversationId, messageId);
+      return ok('Marked as read.');
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/messaging/tools/messaging-read.ts

@@ -0,0 +1,28 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { resolveProvider, withProviderToken, ok, err } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const platform = input.platform as string | undefined;
+  const conversationId = input.conversation_id as string;
+  const limit = input.limit as number | undefined;
+  const threadId = input.thread_id as string | undefined;
+
+  if (!conversationId) {
+    return err('conversation_id is required.');
+  }
+
+  try {
+    const provider = resolveProvider(platform);
+    return withProviderToken(provider, async (token) => {
+      let messages;
+      if (threadId && provider.getThreadReplies) {
+        messages = await provider.getThreadReplies(token, conversationId, threadId, { limit });
+      } else {
+        messages = await provider.getHistory(token, conversationId, { limit });
+      }
+      return ok(JSON.stringify(messages, null, 2));
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/messaging/tools/messaging-reply.ts

@@ -0,0 +1,29 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { resolveProvider, withProviderToken, ok, err } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const platform = input.platform as string | undefined;
+  const conversationId = input.conversation_id as string;
+  const threadId = input.thread_id as string;
+  const text = input.text as string;
+
+  if (!conversationId) {
+    return err('conversation_id is required.');
+  }
+  if (!threadId) {
+    return err('thread_id is required.');
+  }
+  if (!text) {
+    return err('text is required.');
+  }
+
+  try {
+    const provider = resolveProvider(platform);
+    return withProviderToken(provider, async (token) => {
+      const result = await provider.sendMessage(token, conversationId, text, { threadId });
+      return ok(`Reply sent (ID: ${result.id}).`);
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/messaging/tools/messaging-search.ts

@@ -0,0 +1,22 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { resolveProvider, withProviderToken, ok, err } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const platform = input.platform as string | undefined;
+  const query = input.query as string;
+  const maxResults = input.max_results as number | undefined;
+
+  if (!query) {
+    return err('query is required.');
+  }
+
+  try {
+    const provider = resolveProvider(platform);
+    return withProviderToken(provider, async (token) => {
+      const result = await provider.search(token, query, { count: maxResults });
+      return ok(JSON.stringify(result, null, 2));
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/messaging/tools/messaging-send.ts

@@ -0,0 +1,27 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { resolveProvider, withProviderToken, ok, err } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const platform = input.platform as string | undefined;
+  const conversationId = input.conversation_id as string;
+  const text = input.text as string;
+  const subject = input.subject as string | undefined;
+  const inReplyTo = input.in_reply_to as string | undefined;
+
+  if (!conversationId) {
+    return err('conversation_id is required.');
+  }
+  if (!text) {
+    return err('text is required.');
+  }
+
+  try {
+    const provider = resolveProvider(platform);
+    return withProviderToken(provider, async (token) => {
+      const result = await provider.sendMessage(token, conversationId, text, { subject, inReplyTo });
+      return ok(`Message sent (ID: ${result.id}).`);
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/messaging/tools/shared.ts

@@ -0,0 +1,71 @@
+/**
+ * Shared utilities for messaging skill tools.
+ */
+
+import { request as httpsRequest, type RequestOptions as HttpsRequestOptions } from 'node:https';
+import { withValidToken } from '../../../../security/token-manager.js';
+import { getMessagingProvider, getConnectedProviders } from '../../../../messaging/registry.js';
+import type { MessagingProvider } from '../../../../messaging/provider.js';
+import type { ToolExecutionResult } from '../../../../tools/types.js';
+
+export function ok(content: string): ToolExecutionResult {
+  return { content, isError: false };
+}
+
+export function err(message: string): ToolExecutionResult {
+  return { content: message, isError: true };
+}
+
+/**
+ * Resolve the messaging provider from user input.
+ * If platform is specified, look it up directly.
+ * If only one provider is connected, auto-select it.
+ * Otherwise, throw asking the user to specify.
+ */
+export function resolveProvider(platformInput?: string): MessagingProvider {
+  if (platformInput) return getMessagingProvider(platformInput);
+
+  const connected = getConnectedProviders();
+  if (connected.length === 1) return connected[0];
+  if (connected.length === 0) {
+    throw new Error('No messaging platforms are connected. Use messaging_auth_test to check connection status, then set up a platform.');
+  }
+
+  const names = connected.map((p) => `"${p.id}"`).join(', ');
+  throw new Error(`Multiple platforms connected (${names}). Specify platform parameter.`);
+}
+
+/**
+ * Execute a callback with a valid OAuth token for the given provider.
+ */
+export async function withProviderToken<T>(
+  provider: MessagingProvider,
+  fn: (token: string) => Promise<T>,
+): Promise<T> {
+  return withValidToken(provider.credentialService, fn);
+}
+
+/** Make an HTTPS request pinned to a specific resolved IP to prevent DNS rebinding. */
+export function pinnedHttpsRequest(
+  target: URL,
+  resolvedAddress: string,
+  options?: { method?: string; headers?: Record<string, string>; body?: string },
+): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const reqOpts: HttpsRequestOptions = {
+      method: options?.method ?? 'GET',
+      hostname: resolvedAddress,
+      port: target.port ? Number(target.port) : undefined,
+      path: `${target.pathname}${target.search}`,
+      headers: { host: target.host, ...options?.headers },
+      servername: target.hostname,
+    };
+    const req = httpsRequest(reqOpts, (res) => {
+      res.resume();
+      resolve(res.statusCode ?? 0);
+    });
+    req.once('error', reject);
+    if (options?.body) req.write(options.body);
+    req.end();
+  });
+}

package/src/config/bundled-skills/messaging/tools/slack-add-reaction.ts

@@ -0,0 +1,25 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { withValidToken } from '../../../../security/token-manager.js';
+import { getMessagingProvider } from '../../../../messaging/registry.js';
+import { addReaction } from '../../../../messaging/providers/slack/client.js';
+import { ok, err } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const channel = input.channel as string;
+  const timestamp = input.timestamp as string;
+  const emoji = input.emoji as string;
+
+  if (!channel || !timestamp || !emoji) {
+    return err('channel, timestamp, and emoji are all required.');
+  }
+
+  try {
+    const provider = getMessagingProvider('slack');
+    return withValidToken(provider.credentialService, async (token) => {
+      await addReaction(token, channel, timestamp, emoji);
+      return ok(`Added :${emoji}: reaction.`);
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/messaging/tools/slack-leave-channel.ts

@@ -0,0 +1,23 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { withValidToken } from '../../../../security/token-manager.js';
+import { getMessagingProvider } from '../../../../messaging/registry.js';
+import { leaveConversation } from '../../../../messaging/providers/slack/client.js';
+import { ok, err } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const channel = input.channel as string;
+
+  if (!channel) {
+    return err('channel is required.');
+  }
+
+  try {
+    const provider = getMessagingProvider('slack');
+    return withValidToken(provider.credentialService, async (token) => {
+      await leaveConversation(token, channel);
+      return ok('Left channel.');
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/self-upgrade/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: "Self Upgrade"
+description: "Upgrade velly to the latest version, restart the daemon, and restart the gateway"
+user-invocable: true
+metadata: {"vellum": {"emoji": "⬆️"}}
+---
+
+You are performing a self-upgrade of the Vellum assistant. Follow these steps **in order**. Use the `bash` tool to run each command. Confirm each step succeeds before moving to the next.
+
+## Step 1: Record the current version
+
+```bash
+vellum --version
+```
+
+Save this value to report later.
+
+## Step 2: Install the latest velly
+
+```bash
+bun update -g velly
+```
+
+If `velly` was not installed globally via bun, try:
+
+```bash
+npm update -g velly
+```
+
+After updating, verify the new version:
+
+```bash
+vellum --version
+```
+
+## Step 3: Restart the gateway
+
+If a gateway process is running, restart it so it picks up any protocol or dependency changes from the new version:
+
+```bash
+pgrep -f 'vellum-gateway|gateway/src/index.ts' || echo "No gateway process found"
+```
+
+If a gateway PID is found, send it SIGTERM so it drains gracefully:
+
+```bash
+pkill -TERM -f 'vellum-gateway|gateway/src/index.ts'
+```
+
+Then start the gateway again using whatever method the user's deployment uses (e.g. `bun run gateway/src/index.ts`, a systemd service, or a container orchestrator). If you are unsure how the gateway is deployed, ask the user.
+
+## Step 4: Restart the daemon
+
+Use `vellum daemon restart` which stops the old daemon and starts a new one from the updated binary in a single command:
+
+```bash
+vellum daemon restart
+```
+
+Verify it is running:
+
+```bash
+vellum daemon status
+```
+
+**Important:** This is the last step because the current daemon process is the one executing this conversation. After the restart, the new daemon takes over and this session ends gracefully.
+
+## After Upgrade
+
+Report back to the user with:
+- The previous and new velly version
+- Daemon status (running, PID)
+- Gateway status (restarted or not found)
+- Any errors encountered during the process