@vellumai/assistant 0.6.2 → 0.6.4

package/src/daemon/shutdown-handlers.ts

@@ -1,5 +1,6 @@
 import * as Sentry from "@sentry/node";
 
+import type { BackupWorkerHandle } from "../backup/backup-worker.js";
 import type { FilingService } from "../filing/filing-service.js";
 import type { HeartbeatService } from "../heartbeat/heartbeat-service.js";
 import type { HookManager } from "../hooks/manager.js";
@@ -13,6 +14,7 @@ import { getLogger } from "../util/logger.js";
 import { getEnrichmentService } from "../workspace/commit-message-enrichment-service.js";
 import type { WorkspaceHeartbeatService } from "../workspace/heartbeat-service.js";
 import type { DaemonServer } from "./server.js";
+import { runShutdownHooks } from "./shutdown-registry.js";
 
 const log = getLogger("lifecycle");
 
@@ -24,7 +26,9 @@ export interface ShutdownDeps {
   hookManager: HookManager;
   runtimeHttp: RuntimeHttpServer | null;
   scheduler: { stop(): void };
+  feedScheduler: { stop(): void } | null;
   getMemoryWorker: () => { stop(): void } | null;
+  getBackupWorker: () => BackupWorkerHandle | null;
   getQdrantManager: () => QdrantManager | null;
   mcpManager: McpServerManager | null;
   telemetryReporter: { stop(): Promise<void> } | null;
@@ -45,11 +49,18 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
     // Force exit if graceful shutdown takes too long.
     // Set this BEFORE awaiting heartbeat stop and triggering daemon-stop hooks
     // so it covers all potentially-blocking async shutdown work.
+    //
+    // 20s budget: 15s reserved for Meet session teardown
+    // (`MeetSessionManager.shutdownAll`), plus ~5s for the remaining
+    // daemon work (workspace commits, server drain, enrichment, telemetry,
+    // mcp, qdrant, sqlite checkpoint). Without a live Meet session the
+    // rest of the shutdown routinely completes in under a second, so this
+    // bump only changes behavior for the stuck-shutdown path.
     const forceTimer = setTimeout(() => {
       log.warn("Graceful shutdown timed out, forcing exit");
       deps.cleanupPidFile();
       process.exit(1);
-    }, 10_000);
+    }, 20_000);
     forceTimer.unref();
 
     await deps.workspaceHeartbeat.stop();
@@ -62,6 +73,15 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
       // Don't let hook failures block shutdown
     }
 
+    // Run registered skill shutdown hooks (e.g. meet-join session teardown)
+    // before stopping the server so any HTTP round-trips and SSE emissions
+    // still have live transports.
+    try {
+      await runShutdownHooks("daemon-shutdown");
+    } catch (err) {
+      log.warn({ err }, "Skill shutdown hooks failed (non-fatal)");
+    }
+
     // Commit any uncommitted workspace changes before stopping the server.
     // This ensures no workspace state is lost during graceful shutdown.
     try {
@@ -111,7 +131,9 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
     await browserManager.closeAllPages();
     cleanupShellOutputTempFiles();
     deps.scheduler.stop();
+    deps.feedScheduler?.stop();
     deps.getMemoryWorker()?.stop();
+    deps.getBackupWorker()?.stop();
 
     if (deps.mcpManager) {
       try {
@@ -123,9 +145,15 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
 
     await deps.getQdrantManager()?.stop();
 
-    // Checkpoint WAL and close SQLite so no writes are lost on exit.
-    // Checkpoint and close are in separate try blocks so that close()
-    // always runs even if checkpointing throws (e.g. SQLITE_BUSY).
+    // Optimize query planner statistics before closing so they persist for
+    // the next session. Checkpoint WAL and close SQLite so no writes are
+    // lost on exit. Each step is in its own try block so later steps still
+    // run if an earlier one throws (e.g. SQLITE_BUSY).
+    try {
+      getSqlite().exec("PRAGMA optimize");
+    } catch (err) {
+      log.warn({ err }, "PRAGMA optimize at shutdown failed (non-fatal)");
+    }
     try {
       getSqlite().exec("PRAGMA wal_checkpoint(TRUNCATE)");
     } catch (err) {

package/src/daemon/shutdown-registry.ts

@@ -0,0 +1,40 @@
+/**
+ * Registry for skill shutdown hooks.
+ *
+ * Skills register async shutdown callbacks at initialization time. The daemon
+ * calls {@link runShutdownHooks} during graceful shutdown so skill-owned
+ * resources (containers, sockets, etc.) are torn down before the process exits.
+ */
+
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("shutdown-registry");
+
+type ShutdownHook = (reason: string) => Promise<void>;
+
+const hooks = new Map<string, ShutdownHook>();
+
+/**
+ * Register a named shutdown hook. Called by skills at initialization time.
+ * If a hook with the same name already exists it is silently replaced (supports
+ * hot-reload).
+ */
+export function registerShutdownHook(name: string, hook: ShutdownHook): void {
+  hooks.set(name, hook);
+  log.info({ name }, "Shutdown hook registered");
+}
+
+/**
+ * Run all registered shutdown hooks. Each hook receives a human-readable
+ * `reason` string (e.g. "daemon-shutdown"). Failures are logged but do not
+ * prevent other hooks from running.
+ */
+export async function runShutdownHooks(reason: string): Promise<void> {
+  for (const [name, hook] of hooks) {
+    try {
+      await hook(reason);
+    } catch (err) {
+      log.warn({ err, name }, `Shutdown hook "${name}" failed (non-fatal)`);
+    }
+  }
+}

package/src/daemon/tool-side-effects.ts

@@ -15,6 +15,7 @@ import { deliverVerificationSlack } from "../runtime/verification-outbound-actio
 import { updatePublishedAppDeployment } from "../services/published-app-updater.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { getLogger } from "../util/logger.js";
+import { ensureAppSourceWatcher } from "./app-source-watcher.js";
 import { refreshSurfacesForApp } from "./conversation-surfaces.js";
 import type { ToolSetupContext } from "./conversation-tool-setup.js";
 import { isDoordashCommand, updateDoordashProgress } from "./doordash-steps.js";
@@ -109,6 +110,11 @@ registerHook(
         description?: string;
       };
       if (parsed.id) {
+        // The apps directory may have just been created — ensure the
+        // filesystem watcher is running so subsequent file edits
+        // trigger live reload.
+        ensureAppSourceWatcher();
+
         handleAppChange(ctx, parsed.id, broadcastToAllClients);
 
         // Fire-and-forget: generate an app icon in the background.
@@ -209,7 +215,9 @@ registerHook(
     const SETTING_TO_KEY: Record<string, string> = {
       activation_key: "pttActivationKey",
       tts_voice_id: "ttsVoiceId",
+      tts_provider: "ttsProvider",
       conversation_timeout: "voiceConversationTimeoutSeconds",
+      fish_audio_reference_id: "fishAudioReferenceId",
     };
     const key = SETTING_TO_KEY[setting];
     if (!key) return;
@@ -222,6 +230,13 @@ registerHook(
       coerced = typeof raw === "number" ? raw : Number(raw);
     } else if (setting === "tts_voice_id" && typeof raw === "string") {
       coerced = raw.trim();
+    } else if (
+      setting === "fish_audio_reference_id" &&
+      typeof raw === "string"
+    ) {
+      coerced = raw.trim();
+    } else if (setting === "tts_provider" && typeof raw === "string") {
+      coerced = raw.trim();
     }
     broadcastToAllClients?.({
       type: "client_settings_update",

package/src/daemon/transport-hints.ts

@@ -1,33 +1,14 @@
-import { parseInterfaceId } from "../channels/types.js";
 import type { ConversationTransportMetadata } from "./message-types/conversations.js";
 
 /**
- * Build enriched transport hints from conversation transport metadata.
+ * Build transport hints from conversation transport metadata.
  *
- * Interface ID first, then host environment (macOS only), then any
- * client-provided hints. Shared between the conversation creation path
- * (server.ts) and the queue drain path (conversation-process.ts).
+ * Only forwards client-provided hints. Interface identity is already
+ * covered by `<turn_context>`, and host environment fields (home dir,
+ * username) are rendered in the `<workspace>` block.
  */
 export function buildTransportHints(
   transport: ConversationTransportMetadata,
 ): string[] {
-  const hints: string[] = [];
-
-  const interfaceLabel = parseInterfaceId(transport.interfaceId) ?? "vellum";
-  hints.push(`User is messaging from interface: ${interfaceLabel}`);
-
-  if (transport.interfaceId === "macos") {
-    if (transport.hostHomeDir) {
-      hints.push(`Host home directory: ${transport.hostHomeDir}`);
-    }
-    if (transport.hostUsername) {
-      hints.push(`Host username: ${transport.hostUsername}`);
-    }
-  }
-
-  if (transport.hints) {
-    hints.push(...transport.hints);
-  }
-
-  return hints;
+  return transport.hints ? [...transport.hints] : [];
 }

package/src/email/html-renderer.ts

@@ -0,0 +1,76 @@
+/**
+ * Markdown → email-safe HTML renderer.
+ *
+ * Converts a markdown/plain-text email body into a styled HTML document
+ * suitable for email clients.  Uses `marked` for parsing and wraps the
+ * result in a minimal responsive template with inline styles.
+ *
+ * Design constraints:
+ *  - Inline CSS only (no <style> blocks — many email clients strip them).
+ *  - System font stack for maximum compatibility.
+ *  - Dark-mode friendly via prefers-color-scheme media query on the wrapper.
+ *  - Plain-text fallback is always sent alongside; this HTML is additive.
+ */
+
+import { marked } from "marked";
+
+// ---------------------------------------------------------------------------
+// marked configuration
+// ---------------------------------------------------------------------------
+
+marked.setOptions({
+  gfm: true,
+  breaks: true,
+});
+
+// ---------------------------------------------------------------------------
+// Template
+// ---------------------------------------------------------------------------
+
+const FONT_STACK =
+  "-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Helvetica Neue', Arial, sans-serif";
+
+function wrapInEmailTemplate(innerHtml: string): string {
+  return `<!DOCTYPE html>
+<html>
+<head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"></head>
+<body style="margin:0; padding:0; background-color:#f5f5f5; font-family:${FONT_STACK};">
+<table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="background-color:#f5f5f5;">
+<tr><td align="center" style="padding:24px 16px;">
+<table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="max-width:600px; background-color:#ffffff; border-radius:8px; overflow:hidden;">
+<tr><td style="padding:32px 32px 24px 32px; font-family:${FONT_STACK}; font-size:15px; line-height:1.6; color:#1a1a1a;">
+${innerHtml}
+</td></tr>
+</table>
+</td></tr>
+</table>
+</body>
+</html>`;
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Convert a markdown (or plain-text) string into email-safe HTML.
+ *
+ * When the input is already HTML (starts with `<` after trimming), it is
+ * returned as-is — no double-wrapping.
+ */
+export function markdownToEmailHtml(markdown: string): string {
+  const trimmed = markdown.trim();
+
+  // Nothing to render.
+  if (!trimmed) {
+    return "";
+  }
+
+  // Already HTML — don't re-process.
+  if (trimmed.startsWith("<")) {
+    return trimmed;
+  }
+
+  const innerHtml = marked.parse(trimmed) as string;
+  return wrapInEmailTemplate(innerHtml);
+}

package/src/heartbeat/heartbeat-service.ts

@@ -5,6 +5,10 @@ import { getConfig } from "../config/loader.js";
 import type { Speed } from "../config/schemas/inference.js";
 import type { HeartbeatAlert } from "../daemon/message-protocol.js";
 import { bootstrapConversation } from "../memory/conversation-bootstrap.js";
+import {
+  GUARDIAN_PERSONA_TEMPLATE,
+  resolveGuardianPersona,
+} from "../prompts/persona-resolver.js";
 import { isTemplateContent } from "../prompts/system-prompt.js";
 import { readTextFileSync } from "../util/fs.js";
 import { getLogger } from "../util/logger.js";
@@ -23,19 +27,27 @@ const DEFAULT_CHECKLIST = `- Check in with yourself. Read NOW.md. Is it still ac
 const REENGAGEMENT_COOLDOWN_MS = 18 * 60 * 60 * 1000; // 18 hours
 const HEARTBEAT_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
 
+// Stripped-comment form of the guardian persona scaffold. Computed
+// once at module load because stripping comment lines is deterministic
+// and the template itself is a compile-time constant.
+const GUARDIAN_PERSONA_SCAFFOLD_STRIPPED = stripCommentLines(
+  GUARDIAN_PERSONA_TEMPLATE,
+).trim();
+
 /** @internal Exported for testing. */
 export function isShallowProfile(): boolean {
   try {
     const identityPath = getWorkspacePromptPath("IDENTITY.md");
-    const userPath = getWorkspacePromptPath("USER.md");
     const rawIdentity = readTextFileSync(identityPath);
-    const rawUser = readTextFileSync(userPath);
     const identity = rawIdentity != null ? stripCommentLines(rawIdentity) : null;
-    const user = rawUser != null ? stripCommentLines(rawUser) : null;
-    return (
-      isTemplateContent(identity, "IDENTITY.md") &&
-      isTemplateContent(user, "USER.md")
-    );
+    // `resolveGuardianPersona` returns already-stripped, trimmed content
+    // (or null for missing/empty files).
+    const user = resolveGuardianPersona();
+    const userIsEmpty =
+      user == null ||
+      user.length === 0 ||
+      user === GUARDIAN_PERSONA_SCAFFOLD_STRIPPED;
+    return isTemplateContent(identity, "IDENTITY.md") && userIsEmpty;
   } catch {
     return false;
   }
@@ -243,9 +255,83 @@ export class HeartbeatService {
     this._nextRunAt = Date.now() + intervalMs;
   }
 
+  private async runCredentialHealthCheck(): Promise<void> {
+    try {
+      const { checkAllCredentials } = await import(
+        "../credential-health/credential-health-service.js"
+      );
+      const report = await checkAllCredentials();
+      if (report.unhealthy.length > 0) {
+        await this.notifyUnhealthyCredentials(report.unhealthy);
+      }
+    } catch (err) {
+      log.warn({ err }, "Credential health check failed (non-fatal)");
+    }
+  }
+
+  private async notifyUnhealthyCredentials(
+    results: Array<{
+      connectionId: string;
+      provider: string;
+      accountInfo: string | null;
+      status: string;
+      details: string;
+      missingScopes: string[];
+    }>,
+  ): Promise<void> {
+    let emitNotificationSignal: typeof import("../notifications/emit-signal.js").emitNotificationSignal;
+    try {
+      ({ emitNotificationSignal } = await import(
+        "../notifications/emit-signal.js"
+      ));
+    } catch {
+      log.warn("Failed to import notification signal emitter");
+      return;
+    }
+
+    for (const result of results) {
+      const urgency =
+        result.status === "revoked" || result.status === "expired"
+          ? ("high" as const)
+          : ("medium" as const);
+
+      try {
+        await emitNotificationSignal({
+          sourceEventName: "credential.health_alert",
+          sourceChannel: "watcher",
+          sourceContextId: result.connectionId,
+          dedupeKey: `credential-health:${result.connectionId}:${result.status}`,
+          attentionHints: {
+            requiresAction: true,
+            urgency,
+            isAsyncBackground: true,
+            visibleInSourceNow: false,
+          },
+          contextPayload: {
+            provider: result.provider,
+            accountInfo: result.accountInfo,
+            status: result.status,
+            details: result.details,
+            missingScopes: result.missingScopes,
+          },
+          routingIntent: "single_channel",
+        });
+      } catch (err) {
+        log.warn(
+          { err, provider: result.provider, connectionId: result.connectionId },
+          "Failed to emit credential health notification",
+        );
+      }
+    }
+  }
+
   private async executeRun(): Promise<void> {
     log.info("Running heartbeat");
 
+    // Credential health check — surface broken credentials proactively
+    // before the LLM heartbeat prompt runs.
+    await this.runCredentialHealthCheck();
+
     try {
       const config = getConfig().heartbeat;
       const checklist = this.readChecklist();

package/src/home/__tests__/assistant-feed-authoring.test.ts

@@ -0,0 +1,156 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { FeedAction, FeedItem } from "../feed-types.js";
+
+// ─── feed-writer mock ──────────────────────────────────────────────────
+// We mock `appendFeedItem` at the module level so the helper under
+// test delegates to the mock instead of hitting disk. The mock is
+// installed before the dynamic import below so the helper module
+// picks it up during resolution.
+const appendFeedItemMock = mock<(item: FeedItem) => Promise<void>>(
+  async () => {},
+);
+
+mock.module("../feed-writer.js", () => ({
+  appendFeedItem: appendFeedItemMock,
+}));
+
+// Dynamic import — must run after `mock.module` above so the helper
+// resolves against the mocked writer.
+const { writeAssistantFeedItem } =
+  await import("../assistant-feed-authoring.js");
+
+beforeEach(() => {
+  appendFeedItemMock.mockClear();
+});
+
+describe("writeAssistantFeedItem", () => {
+  test("builds an assistant-authored FeedItem and delegates to appendFeedItem", async () => {
+    const item = await writeAssistantFeedItem({
+      type: "nudge",
+      source: "gmail",
+      title: "Urgent email from Alice",
+      summary: "Alice is asking when the deck lands",
+    });
+
+    // Author is hard-coded to "assistant" — this is the whole point
+    // of the helper (wins over platform for the same (type,source)).
+    expect(item.author).toBe("assistant");
+    // Non-empty UUID id was generated.
+    expect(typeof item.id).toBe("string");
+    expect(item.id.length).toBeGreaterThan(0);
+    // Status defaults to "new".
+    expect(item.status).toBe("new");
+    // Semantic fields are passed through untouched.
+    expect(item.type).toBe("nudge");
+    expect(item.source).toBe("gmail");
+    expect(item.title).toBe("Urgent email from Alice");
+    expect(item.summary).toBe("Alice is asking when the deck lands");
+
+    // Delegated to the writer exactly once with the constructed item.
+    expect(appendFeedItemMock.mock.calls).toHaveLength(1);
+    const [appended] = appendFeedItemMock.mock.calls[0]!;
+    expect(appended).toBe(item);
+  });
+
+  test("defaults priority to 60 when not supplied", async () => {
+    const item = await writeAssistantFeedItem({
+      type: "digest",
+      source: "slack",
+      title: "Slack digest",
+      summary: "3 threads need a reply",
+    });
+
+    expect(item.priority).toBe(60);
+    expect(appendFeedItemMock.mock.calls).toHaveLength(1);
+    expect(appendFeedItemMock.mock.calls[0]![0]!.priority).toBe(60);
+  });
+
+  test("passes an explicit priority through untouched", async () => {
+    const item = await writeAssistantFeedItem({
+      type: "nudge",
+      source: "slack",
+      title: "High-priority nudge",
+      summary: "You should look at this",
+      priority: 80,
+    });
+
+    expect(item.priority).toBe(80);
+    expect(appendFeedItemMock.mock.calls[0]![0]!.priority).toBe(80);
+  });
+
+  test("populates createdAt and timestamp as ISO strings", async () => {
+    const before = Date.now();
+    const item = await writeAssistantFeedItem({
+      type: "nudge",
+      title: "Ping",
+      summary: "Ping summary",
+    });
+    const after = Date.now();
+
+    expect(typeof item.timestamp).toBe("string");
+    expect(typeof item.createdAt).toBe("string");
+
+    const timestampMs = Date.parse(item.timestamp);
+    const createdAtMs = Date.parse(item.createdAt);
+    expect(Number.isNaN(timestampMs)).toBe(false);
+    expect(Number.isNaN(createdAtMs)).toBe(false);
+
+    // Both are stamped at call time.
+    expect(timestampMs).toBeGreaterThanOrEqual(before);
+    expect(timestampMs).toBeLessThanOrEqual(after);
+    expect(createdAtMs).toBeGreaterThanOrEqual(before);
+    expect(createdAtMs).toBeLessThanOrEqual(after);
+  });
+
+  test("passes the actions array through untouched", async () => {
+    const actions: FeedAction[] = [
+      { id: "reply", label: "Reply", prompt: "Draft a reply to Alice" },
+      { id: "snooze", label: "Snooze", prompt: "Snooze this for 1 hour" },
+    ];
+
+    const item = await writeAssistantFeedItem({
+      type: "action",
+      source: "gmail",
+      title: "Alice needs a reply",
+      summary: "Reply or snooze",
+      actions,
+    });
+
+    expect(item.actions).toEqual(actions);
+    // Delegated value is the same object the caller passed in.
+    expect(appendFeedItemMock.mock.calls[0]![0]!.actions).toEqual(actions);
+  });
+
+  test("throws a Zod validation error when the constructed item violates the schema", async () => {
+    // Plan calls for a "missing required fields → throws Zod error"
+    // test. The underlying `feedItemSchema` uses `z.string()` (not
+    // `.min(1)`) so an empty title technically parses, but an
+    // out-of-range priority is a guaranteed schema violation and
+    // exercises the same guardrail path: `feedItemSchema.parse()`
+    // rejects the item, the helper rethrows, and `appendFeedItem` is
+    // NEVER called.
+    await expect(
+      writeAssistantFeedItem({
+        type: "nudge",
+        title: "bad",
+        summary: "also bad",
+        priority: 150,
+      }),
+    ).rejects.toThrow();
+
+    // And for the original "missing required field" intent from the
+    // plan: force-omit `title` through a type cast and confirm the
+    // schema still rejects (z.string() rejects `undefined`).
+    await expect(
+      writeAssistantFeedItem({
+        type: "nudge",
+        summary: "no title",
+        // biome-ignore lint/suspicious/noExplicitAny: deliberately invalid
+      } as any),
+    ).rejects.toThrow();
+
+    // The invalid calls must NOT have reached the writer.
+    expect(appendFeedItemMock.mock.calls).toHaveLength(0);
+  });
+});