@vellumai/assistant 0.5.7 → 0.5.8

package/src/config/env.ts

@@ -15,6 +15,7 @@
 
 import { getLogger } from "../util/logger.js";
 import { checkUnrecognizedEnvVars } from "./env-registry.js";
+import { getConfig } from "./loader.js";
 
 const log = getLogger("env");
 
@@ -144,7 +145,19 @@ export function setPlatformBaseUrl(value: string | undefined): void {
 }
 
 export function getPlatformBaseUrl(): string {
-  return str("VELLUM_PLATFORM_URL") ?? _platformBaseUrlOverride ?? "";
+  let configUrl: string | undefined;
+  try {
+    const val = getConfig().platform.baseUrl;
+    if (val) configUrl = val;
+  } catch {
+    // Config not yet available (early bootstrap) — fall through
+  }
+  return (
+    configUrl ||
+    str("VELLUM_PLATFORM_URL") ||
+    _platformBaseUrlOverride ||
+    "https://platform.vellum.ai"
+  );
 }
 
 let _platformAssistantIdOverride: string | undefined;

package/src/config/feature-flag-registry.json

@@ -111,7 +111,7 @@
       "key": "feature_flags.ces-managed-sidecar.enabled",
       "label": "CES Managed Sidecar Transport",
       "description": "Use managed sidecar transport for CES communication when running in a containerized environment",
-      "defaultEnabled": false
+      "defaultEnabled": true
     },
     {
       "id": "ces-credential-backend",

package/src/config/loader.ts

@@ -40,19 +40,16 @@ function ensureMigratedDataDir(): void {
 }
 
 /**
- * Zod 4's .default({}) returns {} as output without running inner-schema
- * parsing, so nested object defaults are never applied. Re-parse the config
- * to cascade defaults through each nesting level.
- * Max chain of .default({}) on object schemas is 4
- * (e.g. memory → retrieval → freshness → maxAgeDays),
- * so 5 parses are needed (N+1) to fully cascade.
+ * Parse a raw config through the Zod schema, applying all nested defaults.
+ *
+ * All nested object schemas use `.default(SubSchema.parse({}))` which
+ * pre-computes fully-resolved defaults at schema construction time, so a
+ * single parse is sufficient to cascade defaults through every nesting level.
  */
 export function applyNestedDefaults(config: unknown): AssistantConfig {
-  let current: unknown = config;
-  for (let i = 0; i < 5; i++) {
-    current = AssistantConfigSchema.parse(current);
-  }
-  return current as AssistantConfig;
+  return structuredClone(
+    AssistantConfigSchema.parse(config),
+  ) as AssistantConfig;
 }
 
 function cloneDefaultConfig(): AssistantConfig {

package/src/config/schema.ts

@@ -68,6 +68,8 @@ export {
   IngressRateLimitConfigSchema,
   IngressWebhookConfigSchema,
 } from "./schemas/ingress.js";
+export type { JournalConfig } from "./schemas/journal.js";
+export { JournalConfigSchema } from "./schemas/journal.js";
 export type { AuditLogConfig, LogFileConfig } from "./schemas/logging.js";
 export {
   AuditLogConfigSchema,
@@ -202,6 +204,7 @@ import {
   ThinkingConfigSchema,
 } from "./schemas/inference.js";
 import { IngressConfigSchema } from "./schemas/ingress.js";
+import { JournalConfigSchema } from "./schemas/journal.js";
 import {
   AuditLogConfigSchema,
   LogFileConfigSchema,
@@ -219,10 +222,7 @@ import {
   PermissionsConfigSchema,
   SecretDetectionConfigSchema,
 } from "./schemas/security.js";
-import {
-  ServicesSchema,
-  VALID_INFERENCE_PROVIDERS,
-} from "./schemas/services.js";
+import { ServicesSchema } from "./schemas/services.js";
 import { SkillsConfigSchema } from "./schemas/skills.js";
 import {
   RateLimitConfigSchema,
@@ -233,18 +233,6 @@ import { WorkspaceGitConfigSchema } from "./schemas/workspace-git.js";
 export const AssistantConfigSchema = z
   .object({
     services: ServicesSchema.default(ServicesSchema.parse({})),
-    providerOrder: z
-      .array(
-        z.enum(VALID_INFERENCE_PROVIDERS, {
-          error: `Each providerOrder entry must be one of: ${VALID_INFERENCE_PROVIDERS.join(
-            ", ",
-          )}`,
-        }),
-      )
-      .default([])
-      .describe(
-        "Fallback order of LLM providers — the assistant tries each in sequence if the previous one fails",
-      ),
     maxTokens: z
       .number({ error: "maxTokens must be a number" })
       .int("maxTokens must be an integer")
@@ -281,6 +269,7 @@ export const AssistantConfigSchema = z
         "Custom pricing overrides for specific provider/model combinations",
       ),
     heartbeat: HeartbeatConfigSchema.default(HeartbeatConfigSchema.parse({})),
+    journal: JournalConfigSchema.default(JournalConfigSchema.parse({})),
     mcp: McpConfigSchema.default(McpConfigSchema.parse({})),
     acp: AcpConfigSchema.default(AcpConfigSchema.parse({})),
     skills: SkillsConfigSchema.default(SkillsConfigSchema.parse({})),

package/src/config/schemas/calls.ts

@@ -70,6 +70,23 @@ export const CallsVoiceConfigSchema = z
       })
       .default("elevenlabs")
       .describe("Text-to-speech provider for phone calls"),
+    hints: z
+      .array(
+        z.string({ error: "calls.voice.hints values must be strings" }),
+      )
+      .default([])
+      .describe(
+        "Static vocabulary hints for speech recognition — proper nouns, domain terms, and other words the STT provider should prioritize",
+      ),
+    interruptSensitivity: z
+      .enum(["low", "medium", "high"], {
+        error:
+          "calls.voice.interruptSensitivity must be one of: low, medium, high",
+      })
+      .default("low")
+      .describe(
+        "How aggressively the STT provider detects the start of caller speech — low reduces false interrupts from background noise",
+      ),
   })
   .describe("Voice and speech settings for phone calls");
 

package/src/config/schemas/inference.ts

@@ -26,8 +26,8 @@ export const ThinkingConfigSchema = z
   .describe("Extended thinking (chain-of-thought) configuration");
 
 export const EffortSchema = z
-  .enum(["low", "medium", "high"], {
-    error: 'effort must be "low", "medium", or "high"',
+  .enum(["low", "medium", "high", "max"], {
+    error: 'effort must be "low", "medium", "high", or "max"',
   })
   .default("high")
   .describe(

package/src/config/schemas/journal.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+
+export const JournalConfigSchema = z
+  .object({
+    contextWindowSize: z
+      .number({ error: "journal.contextWindowSize must be a number" })
+      .int("journal.contextWindowSize must be an integer")
+      .min(0, "journal.contextWindowSize must be >= 0")
+      .default(10)
+      .describe(
+        "Number of recent journal entries to include in context (0 to disable)",
+      ),
+  })
+  .describe("Journal context window configuration");
+
+export type JournalConfig = z.infer<typeof JournalConfigSchema>;

package/src/config/schemas/memory-processing.ts

@@ -12,7 +12,7 @@ export const MemoryExtractionConfigSchema = z
       .enum(["latency-optimized", "quality-optimized", "vision-optimized"], {
         error: "memory.extraction.modelIntent must be a valid model intent",
       })
-      .default("latency-optimized")
+      .default("quality-optimized")
       .describe(
         "Model selection strategy for extraction — trade off speed vs quality",
       ),
@@ -39,7 +39,7 @@ export const MemorySummarizationConfigSchema = z
       .enum(["latency-optimized", "quality-optimized", "vision-optimized"], {
         error: "memory.summarization.modelIntent must be a valid model intent",
       })
-      .default("latency-optimized")
+      .default("quality-optimized")
       .describe(
         "Model selection strategy for summarization — trade off speed vs quality",
       ),

package/src/config/types.ts

@@ -12,6 +12,7 @@ export type {
   ImageGenerationService,
   InferenceService,
   IngressConfig,
+  JournalConfig,
   LogFileConfig,
   MemoryConfig,
   MemoryEmbeddingsConfig,

package/src/contacts/contact-store.ts

@@ -38,7 +38,7 @@ export function generateUserFileSlug(displayName: string): string {
       .toLowerCase()
       .replace(/[^a-z0-9]+/g, "-")
       .replace(/^-+|-+$/g, "")
-      .slice(0, 50) || "user";
+      .slice(0, 100) || "user";
 
   const db = getDb();
   const rows = db
@@ -47,7 +47,7 @@ export function generateUserFileSlug(displayName: string): string {
     .where(like(contacts.userFile, `${escapeLike(slug)}%`))
     .all();
 
-  const taken = new Set(rows.map((r) => r.userFile));
+  const taken = new Set(rows.map((r) => r.userFile?.toLowerCase()));
 
   const base = `${slug}.md`;
   if (!taken.has(base)) return base;

package/src/credential-execution/executable-discovery.ts

@@ -127,7 +127,7 @@ export function discoverLocalCes():
   }
 
   // Fallback: check for source entry point in the monorepo
-  const monorepoRoot = join(import.meta.dir, "..", "..", "..", "..");
+  const monorepoRoot = join(import.meta.dir, "..", "..", "..");
   const sourceEntry = join(
     monorepoRoot,
     "credential-executor",

package/src/credential-execution/startup-timeout.ts

@@ -0,0 +1,36 @@
+import type { CesClient } from "./client.js";
+
+export interface AwaitCesClientWithTimeoutOptions {
+  timeoutMs?: number;
+  onTimeout?: () => void;
+}
+
+export const DEFAULT_CES_STARTUP_TIMEOUT_MS = 20_000;
+
+export async function awaitCesClientWithTimeout(
+  clientPromise: Promise<CesClient | undefined>,
+  options: AwaitCesClientWithTimeoutOptions = {},
+): Promise<CesClient | undefined> {
+  const {
+    timeoutMs = DEFAULT_CES_STARTUP_TIMEOUT_MS,
+    onTimeout = () => {},
+  } = options;
+
+  let timeoutId: ReturnType<typeof setTimeout> | undefined;
+
+  try {
+    return await Promise.race([
+      clientPromise,
+      new Promise<undefined>((resolve) => {
+        timeoutId = setTimeout(() => {
+          onTimeout();
+          resolve(undefined);
+        }, timeoutMs);
+      }),
+    ]);
+  } finally {
+    if (timeoutId !== undefined) {
+      clearTimeout(timeoutId);
+    }
+  }
+}

package/src/daemon/approval-generators.ts

@@ -1,5 +1,5 @@
 import { loadConfig } from "../config/loader.js";
-import { getFailoverProvider, listProviders } from "../providers/registry.js";
+import { getProvider, listProviders } from "../providers/registry.js";
 import {
   APPROVAL_COPY_MAX_TOKENS,
   APPROVAL_COPY_SYSTEM_PROMPT,
@@ -91,10 +91,7 @@ export function createApprovalCopyGenerator(): ApprovalCopyGenerator {
     const config = loadConfig();
     let provider;
     try {
-      provider = getFailoverProvider(
-        config.services.inference.provider,
-        config.providerOrder,
-      );
+      provider = getProvider(config.services.inference.provider);
     } catch {
       return null;
     }
@@ -148,10 +145,7 @@ export function createApprovalConversationGenerator(): ApprovalConversationGener
     if (!listProviders().includes(config.services.inference.provider)) {
       throw new Error("No provider available for approval conversation");
     }
-    const provider = getFailoverProvider(
-      config.services.inference.provider,
-      config.providerOrder,
-    );
+    const provider = getProvider(config.services.inference.provider);
 
     const pendingDescription = context.pendingApprovals
       .map((p) => `- Request ${p.requestId}: tool "${p.toolName}"`)

package/src/daemon/conversation-error.ts

@@ -1,4 +1,4 @@
-import { ProviderError } from "../util/errors.js";
+import { ProviderError, ProviderNotConfiguredError } from "../util/errors.js";
 import type {
   ConversationErrorCode,
   ConversationErrorMessage,
@@ -149,6 +149,18 @@ export function classifyConversationError(
     (error instanceof Error ? error.stack : undefined) ?? message;
   const debugDetails = truncateDebugDetails(rawDetails);
 
+  // Dedicated classification for missing provider API key
+  if (error instanceof ProviderNotConfiguredError) {
+    return {
+      code: "PROVIDER_NOT_CONFIGURED",
+      userMessage:
+        "No API key configured for inference. Add one in Settings to start chatting.",
+      retryable: true,
+      errorCategory: "provider_not_configured",
+      debugDetails,
+    };
+  }
+
   // Phase-specific overrides
   if (ctx.phase === "regenerate") {
     const base = classifyCore(error, message);

package/src/daemon/conversation-memory.ts

@@ -92,7 +92,6 @@ export async function prepareMemoryContext(
       degraded: false,
       injectedText: "",
       semanticHits: 0,
-      recencyHits: 0,
       mergedCount: 0,
       selectedCount: 0,
       injectedTokens: 0,
@@ -188,7 +187,7 @@ export async function prepareMemoryContext(
             }
           : undefined,
         semanticHits: recall.semanticHits,
-        recencyHits: recall.recencyHits,
+        recencyHits: 0,
         tier1Count: recall.tier1Count ?? 0,
         tier2Count: recall.tier2Count ?? 0,
         hybridSearchLatencyMs: recall.hybridSearchMs ?? 0,

package/src/daemon/conversation-process.ts

@@ -31,7 +31,10 @@ import { routeGuardianReply } from "../runtime/guardian-reply-router.js";
 import { getLogger } from "../util/logger.js";
 import type { MessageQueue } from "./conversation-queue-manager.js";
 import type { QueueDrainReason } from "./conversation-queue-manager.js";
-import type { TrustContext } from "./conversation-runtime-assembly.js";
+import type {
+  ChannelCapabilities,
+  TrustContext,
+} from "./conversation-runtime-assembly.js";
 import { resolveSlash, type SlashContext } from "./conversation-slash.js";
 import { getModelInfo } from "./handlers/config-model.js";
 import type {
@@ -80,6 +83,11 @@ export interface ProcessConversationContext {
   /** Assistant identity — used for scoping notification preferences. */
   readonly assistantId?: string;
   trustContext?: TrustContext;
+  channelCapabilities?: ChannelCapabilities;
+  /** Per-turn snapshot of trustContext, frozen at message-processing start. */
+  currentTurnTrustContext?: TrustContext;
+  /** Per-turn snapshot of channelCapabilities, frozen at message-processing start. */
+  currentTurnChannelCapabilities?: ChannelCapabilities;
   ensureActorScopedHistory(): Promise<void>;
   persistUserMessage(
     content: string,
@@ -282,6 +290,11 @@ export async function drainQueue(
     }
   }
 
+  // Snapshot persona context at turn start so later tool turns can't pick up
+  // a different actor's context if a concurrent request mutates the live fields.
+  conversation.currentTurnTrustContext = conversation.trustContext;
+  conversation.currentTurnChannelCapabilities = conversation.channelCapabilities;
+
   // Resolve slash commands for queued messages
   const slashResult = await resolveSlash(
     next.content,
@@ -561,6 +574,10 @@ export async function processMessage(
   displayContent?: string,
 ): Promise<string> {
   await conversation.ensureActorScopedHistory();
+  // Snapshot persona context at turn start so later tool turns can't pick up
+  // a different actor's context if a concurrent request mutates the live fields.
+  conversation.currentTurnTrustContext = conversation.trustContext;
+  conversation.currentTurnChannelCapabilities = conversation.channelCapabilities;
   conversation.currentActiveSurfaceId = activeSurfaceId;
   conversation.currentPage = currentPage;
   const trimmedContent = content.trim();

package/src/daemon/conversation-surfaces.ts

@@ -2,7 +2,10 @@ import { v4 as uuid } from "uuid";
 
 import {
   getApp,
+  getAppDirPath,
   getAppPreview,
+  inlineDistAssets,
+  isMultifileApp,
   resolveAppDir,
   updateApp,
 } from "../memory/app-store.js";
@@ -1364,8 +1367,34 @@ export async function surfaceProxyResolver(
 
     const storedPreview = getAppPreview(app.id);
     const { dirName } = resolveAppDir(app.id);
+
+    // For multifile TSX apps, resolve HTML from compiled dist/index.html
+    // rather than the root index.html (which is empty for formatVersion 2).
+    let html = app.htmlDefinition;
+    if (isMultifileApp(app)) {
+      const { existsSync, readFileSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const appDir = getAppDirPath(app.id);
+      const distIndex = join(appDir, "dist", "index.html");
+      if (!existsSync(distIndex)) {
+        const { compileApp } = await import("../bundler/app-compiler.js");
+        const result = await compileApp(appDir);
+        if (!result.ok) {
+          log.warn(
+            { appId, errors: result.errors },
+            "Auto-compile failed on app_open",
+          );
+        }
+      }
+      if (existsSync(distIndex)) {
+        html = inlineDistAssets(appDir, readFileSync(distIndex, "utf-8"));
+      } else {
+        html = `<p>App compilation failed. Edit a source file to trigger a rebuild.</p>`;
+      }
+    }
+
     const surfaceData: DynamicPageSurfaceData = {
-      html: app.htmlDefinition,
+      html,
       appId: app.id,
       dirName,
       preview: {

package/src/daemon/conversation.ts

@@ -176,6 +176,14 @@ export class Conversation {
   /** @internal */ currentPage?: string;
   /** @internal */ channelCapabilities?: ChannelCapabilities;
   /** @internal */ trustContext?: TrustContext;
+  /**
+   * Per-turn snapshots of persona-relevant context, captured at the start of
+   * each message processing turn. The system prompt callback reads these
+   * instead of the live fields so that a concurrent request cannot swap
+   * another actor's persona mid-turn.
+   */
+  /** @internal */ currentTurnTrustContext?: TrustContext;
+  /** @internal */ currentTurnChannelCapabilities?: ChannelCapabilities;
   /** @internal */ authContext?: AuthContext;
   /** @internal */ loadedHistoryTrustClass?: TrustClass;
   /** @internal */ voiceCallControlPrompt?: string;
@@ -354,18 +362,21 @@ export class Conversation {
     const resolveSystemPromptCallback = (
       _history: import("../providers/types.js").Message[],
     ): ResolvedSystemPrompt => {
-      const persona = resolvePersonaContext(
-        this.trustContext,
-        this.channelCapabilities,
-      );
       const resolved = {
         systemPrompt: hasSystemPromptOverride
           ? systemPrompt
-          : buildSystemPrompt({
-              hasNoClient: this.hasNoClient,
-              userPersona: persona.userPersona,
-              channelPersona: persona.channelPersona,
-            }),
+          : (() => {
+              const persona = resolvePersonaContext(
+                this.currentTurnTrustContext,
+                this.currentTurnChannelCapabilities,
+              );
+              return buildSystemPrompt({
+                hasNoClient: this.hasNoClient,
+                userPersona: persona.userPersona,
+                channelPersona: persona.channelPersona,
+                userSlug: persona.userSlug,
+              });
+            })(),
         maxTokens: configuredMaxTokens,
       };
       return resolved;

package/src/daemon/guardian-action-generators.ts

@@ -1,5 +1,5 @@
 import { loadConfig } from "../config/loader.js";
-import { getFailoverProvider } from "../providers/registry.js";
+import { getProvider } from "../providers/registry.js";
 import {
   buildGuardianActionGenerationPrompt,
   getGuardianActionFallbackMessage,
@@ -29,10 +29,7 @@ export function createGuardianActionCopyGenerator(): GuardianActionCopyGenerator
     const config = loadConfig();
     let provider;
     try {
-      provider = getFailoverProvider(
-        config.services.inference.provider,
-        config.providerOrder,
-      );
+      provider = getProvider(config.services.inference.provider);
     } catch {
       return null;
     }
@@ -134,10 +131,7 @@ const VALID_FOLLOWUP_DISPOSITIONS: ReadonlySet<string> = new Set([
 export function createGuardianFollowUpConversationGenerator(): GuardianFollowUpConversationGenerator {
   return async (context) => {
     const config = loadConfig();
-    const provider = getFailoverProvider(
-      config.services.inference.provider,
-      config.providerOrder,
-    );
+    const provider = getProvider(config.services.inference.provider);
 
     const userPrompt = [
       `Original question from the voice call: "${context.questionText}"`,

package/src/daemon/lifecycle.ts

@@ -28,6 +28,10 @@ import {
   CesUnavailableError,
   createCesProcessManager,
 } from "../credential-execution/process-manager.js";
+import {
+  awaitCesClientWithTimeout,
+  DEFAULT_CES_STARTUP_TIMEOUT_MS,
+} from "../credential-execution/startup-timeout.js";
 import { HeartbeatService } from "../heartbeat/heartbeat-service.js";
 import { getHookManager } from "../hooks/manager.js";
 import { installTemplates } from "../hooks/templates.js";
@@ -161,7 +165,8 @@ export interface CesStartupResult {
 export async function startCesProcess(
   config: AssistantConfig,
 ): Promise<CesStartupResult> {
-  const shouldStartCes = isCesToolsEnabled(config) || isCesCredentialBackendEnabled(config);
+  const shouldStartCes =
+    isCesToolsEnabled(config) || isCesCredentialBackendEnabled(config);
   if (!shouldStartCes) {
     return {
       client: undefined,
@@ -456,23 +461,25 @@ export async function runDaemon(): Promise<void> {
 
     // When the credential backend flag is enabled, CES startup must complete
     // BEFORE provider initialization so credential reads can go through CES.
-    // Block with a 3-second timeout — fall back to direct credential store
+    // Block with a 20-second timeout — fall back to direct credential store
     // on timeout.
     if (isCesCredentialBackendEnabled(config)) {
       const cesResult = await cesStartupPromise;
       // startCesProcess() returns immediately — the actual handshake runs
-      // inside clientPromise. Await it (with a 3s timeout) so the CES client
+      // inside clientPromise. Await it (with a 20s timeout) so the CES client
       // is available before provider initialization.
       if (cesResult.clientPromise) {
-        const client = await Promise.race([
+        const client = await awaitCesClientWithTimeout(
           cesResult.clientPromise,
-          new Promise<undefined>((resolve) =>
-            setTimeout(() => {
-              log.warn("CES handshake timed out after 3s — falling back to direct credential store");
-              resolve(undefined);
-            }, 3000),
-          ),
-        ]);
+          {
+            timeoutMs: DEFAULT_CES_STARTUP_TIMEOUT_MS,
+            onTimeout: () => {
+              log.warn(
+                "CES handshake timed out after 20s — falling back to direct credential store",
+              );
+            },
+          },
+        );
         if (client) {
           setCesClient(client);
         }

package/src/daemon/message-types/conversations.ts

@@ -371,6 +371,7 @@ export type ConversationErrorCode =
   | "PROVIDER_BILLING"
   | "PROVIDER_ORDERING"
   | "PROVIDER_WEB_SEARCH"
+  | "PROVIDER_NOT_CONFIGURED"
   | "CONTEXT_TOO_LARGE"
   | "CONVERSATION_ABORTED"
   | "CONVERSATION_PROCESSING_FAILED"

package/src/daemon/server.ts

@@ -41,7 +41,7 @@ import { getOrCreateConversation } from "../memory/conversation-key-store.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
 import { RateLimitProvider } from "../providers/ratelimit.js";
 import {
-  getFailoverProvider,
+  getProvider,
   initializeProviders,
 } from "../providers/registry.js";
 import { buildAssistantEvent } from "../runtime/assistant-event.js";
@@ -702,9 +702,8 @@ export class DaemonServer {
 
       const createPromise = (async () => {
         const config = getConfig();
-        let provider = getFailoverProvider(
+        let provider = getProvider(
           config.services.inference.provider,
-          config.providerOrder,
         );
         const { rateLimit } = config;
         if (rateLimit.maxRequestsPerMinute > 0) {

package/src/memory/app-store.ts

@@ -64,6 +64,37 @@ export function isMultifileApp(app: AppDefinition): boolean {
   return app.formatVersion === 2;
 }
 
+/**
+ * Inline dist assets (main.js, main.css) into the compiled HTML so it can be
+ * delivered as a self-contained string via loadHTMLString/SSE without needing
+ * the client to resolve external script/stylesheet URLs.
+ */
+export function inlineDistAssets(appDir: string, html: string): string {
+  const distDir = join(appDir, "dist");
+
+  // Inline main.js
+  const jsPath = join(distDir, "main.js");
+  if (existsSync(jsPath)) {
+    const js = readFileSync(jsPath, "utf-8");
+    html = html.replace(
+      /<script\s+type="module"\s+src="main\.js"\s*><\/script>/,
+      `<script type="module">${js}</script>`,
+    );
+  }
+
+  // Inline main.css
+  const cssPath = join(distDir, "main.css");
+  if (existsSync(cssPath)) {
+    const css = readFileSync(cssPath, "utf-8");
+    html = html.replace(
+      /<link\s+rel="stylesheet"\s+href="main\.css"\s*>/,
+      `<style>${css}</style>`,
+    );
+  }
+
+  return html;
+}
+
 export interface AppRecord {
   id: string;
   appId: string;

package/src/memory/db-init.ts

@@ -34,6 +34,7 @@ import {
   createSequenceTables,
   createTasksAndWorkItemsTables,
   createWatchersAndLogsTables,
+  migrateAddSourceTypeColumns,
   migrateAssistantContactMetadata,
   migrateBackfillAudioAttachmentMimeTypes,
   migrateBackfillContactInteractionStats,
@@ -504,6 +505,9 @@ export function initializeDb(): void {
   // 89. Add user_file column to contacts for per-user persona file mapping
   migrateContactsUserFileColumn(database);
 
+  // 90. Add source_type and source_message_role columns to memory_items
+  migrateAddSourceTypeColumns(database);
+
   validateMigrationState(database);
 
   if (process.env.BUN_TEST === "1") {