@vellumai/assistant 0.6.3 → 0.6.5

package/src/config/schemas/tts.ts

@@ -0,0 +1,283 @@
+import { z } from "zod";
+
+import { listCatalogProviderIds } from "../../tts/provider-catalog.js";
+import type { TtsProviderId } from "../../tts/types.js";
+import {
+  DEFAULT_ELEVENLABS_VOICE_ID,
+  VALID_CONVERSATION_TIMEOUTS,
+} from "./elevenlabs.js";
+
+/**
+ * Valid TTS provider identifiers derived from the canonical provider catalog.
+ *
+ * Adding a new TTS provider starts in `provider-catalog.ts` — the IDs flow
+ * here automatically.
+ */
+export const VALID_TTS_PROVIDERS: readonly [string, ...string[]] =
+  listCatalogProviderIds() as [TtsProviderId, ...TtsProviderId[]];
+
+/**
+ * Per-provider config schemas nested under `services.tts.providers.<id>`.
+ *
+ * Each provider's schema is the full provider-specific config (voice ID,
+ * model overrides, tuning params, etc.). These are identical to the
+ * legacy top-level schemas (`elevenlabs.*`, `fishAudio.*`) so that
+ * migration can copy values 1:1.
+ */
+export const TtsElevenLabsProviderConfigSchema = z
+  .object({
+    voiceId: z
+      .string({
+        error: "services.tts.providers.elevenlabs.voiceId must be a string",
+      })
+      .transform((v) => v || DEFAULT_ELEVENLABS_VOICE_ID)
+      .default(DEFAULT_ELEVENLABS_VOICE_ID)
+      .describe("ElevenLabs voice ID for text-to-speech"),
+    voiceModelId: z
+      .string({
+        error:
+          "services.tts.providers.elevenlabs.voiceModelId must be a string",
+      })
+      .default("")
+      .describe(
+        "ElevenLabs model ID override (leave empty to use the default model)",
+      ),
+    speed: z
+      .number({
+        error: "services.tts.providers.elevenlabs.speed must be a number",
+      })
+      .min(0.7, "services.tts.providers.elevenlabs.speed must be >= 0.7")
+      .max(1.2, "services.tts.providers.elevenlabs.speed must be <= 1.2")
+      .default(1.0)
+      .describe(
+        "Speech playback speed multiplier (0.7 = slower, 1.2 = faster)",
+      ),
+    stability: z
+      .number({
+        error: "services.tts.providers.elevenlabs.stability must be a number",
+      })
+      .min(0, "services.tts.providers.elevenlabs.stability must be >= 0")
+      .max(1, "services.tts.providers.elevenlabs.stability must be <= 1")
+      .default(0.5)
+      .describe(
+        "Voice stability — higher values produce more consistent speech, lower values add expressiveness",
+      ),
+    similarityBoost: z
+      .number({
+        error:
+          "services.tts.providers.elevenlabs.similarityBoost must be a number",
+      })
+      .min(0, "services.tts.providers.elevenlabs.similarityBoost must be >= 0")
+      .max(1, "services.tts.providers.elevenlabs.similarityBoost must be <= 1")
+      .default(0.75)
+      .describe(
+        "How closely the output matches the original voice — higher values increase similarity",
+      ),
+    conversationTimeoutSeconds: z
+      .number({
+        error:
+          "services.tts.providers.elevenlabs.conversationTimeoutSeconds must be a number",
+      })
+      .refine(
+        (v) =>
+          VALID_CONVERSATION_TIMEOUTS.includes(
+            v as (typeof VALID_CONVERSATION_TIMEOUTS)[number],
+          ),
+        {
+          message: `services.tts.providers.elevenlabs.conversationTimeoutSeconds must be one of: ${VALID_CONVERSATION_TIMEOUTS.join(", ")}`,
+        },
+      )
+      .default(30)
+      .describe("Seconds of silence before voice conversation auto-ends"),
+  })
+  .describe("ElevenLabs provider configuration under services.tts");
+
+export type TtsElevenLabsProviderConfig = z.infer<
+  typeof TtsElevenLabsProviderConfigSchema
+>;
+
+export const TtsFishAudioProviderConfigSchema = z
+  .object({
+    referenceId: z
+      .string({
+        error: "services.tts.providers.fish-audio.referenceId must be a string",
+      })
+      .default("")
+      .describe("Fish Audio voice/clone reference ID"),
+    chunkLength: z
+      .number({
+        error: "services.tts.providers.fish-audio.chunkLength must be a number",
+      })
+      .int("services.tts.providers.fish-audio.chunkLength must be an integer")
+      .min(100, "services.tts.providers.fish-audio.chunkLength must be >= 100")
+      .max(300, "services.tts.providers.fish-audio.chunkLength must be <= 300")
+      .default(200)
+      .describe("Text chunk size for streaming synthesis"),
+    format: z
+      .enum(["mp3", "wav", "opus"], {
+        error:
+          "services.tts.providers.fish-audio.format must be one of: mp3, wav, opus",
+      })
+      .default("mp3")
+      .describe("Output audio format"),
+    latency: z
+      .enum(["normal", "balanced"], {
+        error:
+          "services.tts.providers.fish-audio.latency must be one of: normal, balanced",
+      })
+      .default("normal")
+      .describe(
+        "Latency/quality tradeoff for Fish Audio S2 synthesis. 'normal' prioritizes lower latency; 'balanced' trades latency for higher quality.",
+      ),
+    speed: z
+      .number({
+        error: "services.tts.providers.fish-audio.speed must be a number",
+      })
+      .min(0.5, "services.tts.providers.fish-audio.speed must be >= 0.5")
+      .max(2.0, "services.tts.providers.fish-audio.speed must be <= 2.0")
+      .default(1.0)
+      .describe("Playback speed multiplier (0.5 = slower, 2.0 = faster)"),
+  })
+  .describe("Fish Audio provider configuration under services.tts");
+
+export type TtsFishAudioProviderConfig = z.infer<
+  typeof TtsFishAudioProviderConfigSchema
+>;
+
+export const TtsDeepgramProviderConfigSchema = z
+  .object({
+    model: z
+      .string({
+        error: "services.tts.providers.deepgram.model must be a string",
+      })
+      .transform((v) => v || "aura-asteria-en")
+      .default("aura-asteria-en")
+      .describe("Deepgram TTS model identifier"),
+    format: z
+      .enum(["mp3", "wav", "opus"], {
+        error:
+          "services.tts.providers.deepgram.format must be one of: mp3, wav, opus",
+      })
+      .default("mp3")
+      .describe("Output audio format for call/runtime playback"),
+  })
+  .describe("Deepgram provider configuration under services.tts");
+
+export type TtsDeepgramProviderConfig = z.infer<
+  typeof TtsDeepgramProviderConfigSchema
+>;
+
+export const TtsXaiProviderConfigSchema = z
+  .object({
+    voiceId: z
+      .string({
+        error: "services.tts.providers.xai.voiceId must be a string",
+      })
+      .transform((v) => v || "eve")
+      .default("eve")
+      .describe(
+        "xAI voice ID — one of: eve, ara, rex, sal, leo (case-insensitive)",
+      ),
+    language: z
+      .string({
+        error: "services.tts.providers.xai.language must be a string",
+      })
+      .default("auto")
+      .describe(
+        "BCP-47 language code (e.g. 'en-US') or 'auto' for auto-detection",
+      ),
+    format: z
+      .enum(["mp3", "wav"], {
+        error: "services.tts.providers.xai.format must be one of: mp3, wav",
+      })
+      .default("mp3")
+      .describe("Output audio format for call/runtime playback"),
+    sampleRate: z
+      .number({
+        error: "services.tts.providers.xai.sampleRate must be a number",
+      })
+      .int("services.tts.providers.xai.sampleRate must be an integer")
+      .refine((v) => [8000, 16000, 22050, 24000, 44100, 48000].includes(v), {
+        message:
+          "services.tts.providers.xai.sampleRate must be one of: 8000, 16000, 22050, 24000, 44100, 48000",
+      })
+      .default(24000)
+      .describe("Output sample rate in Hz"),
+    bitRate: z
+      .number({
+        error: "services.tts.providers.xai.bitRate must be a number",
+      })
+      .int("services.tts.providers.xai.bitRate must be an integer")
+      .refine((v) => [32000, 64000, 96000, 128000, 192000].includes(v), {
+        message:
+          "services.tts.providers.xai.bitRate must be one of: 32000, 64000, 96000, 128000, 192000",
+      })
+      .default(128000)
+      .describe("MP3 bit rate (ignored for non-MP3 codecs)"),
+  })
+  .describe("xAI provider configuration under services.tts");
+
+export type TtsXaiProviderConfig = z.infer<typeof TtsXaiProviderConfigSchema>;
+
+export const TtsProvidersSchema = z.object({
+  elevenlabs: TtsElevenLabsProviderConfigSchema.default(
+    TtsElevenLabsProviderConfigSchema.parse({}),
+  ),
+  "fish-audio": TtsFishAudioProviderConfigSchema.default(
+    TtsFishAudioProviderConfigSchema.parse({}),
+  ),
+  deepgram: TtsDeepgramProviderConfigSchema.default(
+    TtsDeepgramProviderConfigSchema.parse({}),
+  ),
+  xai: TtsXaiProviderConfigSchema.default(TtsXaiProviderConfigSchema.parse({})),
+});
+export type TtsProviders = z.infer<typeof TtsProvidersSchema>;
+
+// ---------------------------------------------------------------------------
+// Catalog-completeness guard
+// ---------------------------------------------------------------------------
+// Ensures every provider in the catalog has a corresponding key in
+// TtsProvidersSchema. If a new provider is added to the catalog without a
+// schema entry, this fires at module-load time so the oversight is caught
+// immediately rather than at runtime when a user selects the provider.
+// ---------------------------------------------------------------------------
+const schemaKeys = new Set(Object.keys(TtsProvidersSchema.shape));
+for (const id of VALID_TTS_PROVIDERS) {
+  if (!schemaKeys.has(id)) {
+    throw new Error(
+      `TTS provider "${id}" exists in the catalog but has no schema entry ` +
+        `in TtsProvidersSchema. Add a "services.tts.providers.${id}" schema.`,
+    );
+  }
+}
+
+/**
+ * Canonical TTS service configuration.
+ *
+ * `mode` is locked to `"your-own"` — managed TTS is not supported.
+ * Attempting to set `mode: "managed"` will fail schema validation.
+ */
+export const TtsServiceSchema = z
+  .object({
+    mode: z
+      .literal("your-own", {
+        error:
+          'services.tts.mode must be "your-own" — managed TTS is not supported',
+      })
+      .default("your-own" as const)
+      .describe(
+        'TTS service mode — only "your-own" is supported (managed TTS is not available)',
+      ),
+    provider: z
+      .enum(VALID_TTS_PROVIDERS, {
+        error: `services.tts.provider must be one of: ${VALID_TTS_PROVIDERS.join(", ")}`,
+      })
+      .default("elevenlabs")
+      .describe("Active TTS provider used for speech synthesis"),
+    providers: TtsProvidersSchema.default(TtsProvidersSchema.parse({})),
+  })
+  .describe(
+    "Text-to-speech service configuration — provider selection and per-provider settings",
+  );
+
+export type TtsService = z.infer<typeof TtsServiceSchema>;

package/src/config/schemas/updates.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+
+export const UpdatesConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({ error: "updates.enabled must be a boolean" })
+      .default(true)
+      .describe(
+        "Whether to dispatch a background conversation when <workspace>/UPDATES.md has unprocessed content. When false, release-update bulletins are written by migrations but never processed by the agent.",
+      ),
+  })
+  .describe("Release update bulletin configuration");
+
+export type UpdatesConfig = z.infer<typeof UpdatesConfigSchema>;

package/src/config/schemas/workspace-git.ts

@@ -74,21 +74,6 @@ export const WorkspaceGitConfigSchema = z
           })
           .default(false)
           .describe("Whether to use an LLM to generate commit messages"),
-        useConfiguredProvider: z
-          .boolean({
-            error:
-              "workspaceGit.commitMessageLLM.useConfiguredProvider must be a boolean",
-          })
-          .default(true)
-          .describe(
-            "Whether to use the globally configured LLM provider for commit messages",
-          ),
-        providerFastModelOverrides: z
-          .record(z.string(), z.string())
-          .default({} as Record<string, string>)
-          .describe(
-            "Map of provider names to fast model overrides for commit message generation",
-          ),
         timeoutMs: z
           .number({
             error: "workspaceGit.commitMessageLLM.timeoutMs must be a number",
@@ -99,26 +84,6 @@ export const WorkspaceGitConfigSchema = z
           )
           .default(600)
           .describe("Timeout for LLM commit message generation (ms)"),
-        maxTokens: z
-          .number({
-            error: "workspaceGit.commitMessageLLM.maxTokens must be a number",
-          })
-          .int("workspaceGit.commitMessageLLM.maxTokens must be an integer")
-          .positive(
-            "workspaceGit.commitMessageLLM.maxTokens must be a positive integer",
-          )
-          .default(120)
-          .describe("Maximum number of tokens in the generated commit message"),
-        temperature: z
-          .number({
-            error: "workspaceGit.commitMessageLLM.temperature must be a number",
-          })
-          .min(0, "workspaceGit.commitMessageLLM.temperature must be >= 0")
-          .max(2, "workspaceGit.commitMessageLLM.temperature must be <= 2")
-          .default(0.2)
-          .describe(
-            "LLM sampling temperature for commit message generation (lower = more deterministic)",
-          ),
         maxFilesInPrompt: z
           .number({
             error:
@@ -203,11 +168,7 @@ export const WorkspaceGitConfigSchema = z
       })
       .default({
         enabled: false,
-        useConfiguredProvider: true,
-        providerFastModelOverrides: {},
         timeoutMs: 600,
-        maxTokens: 120,
-        temperature: 0.2,
         maxFilesInPrompt: 30,
         maxDiffBytes: 12000,
         minRemainingTurnBudgetMs: 1000,
@@ -217,7 +178,9 @@ export const WorkspaceGitConfigSchema = z
           backoffMaxMs: 60000,
         },
       })
-      .describe("LLM-powered commit message generation settings"),
+      .describe(
+        "LLM-powered commit message generation operational settings. Provider/model/maxTokens/temperature live under llm.callSites.commitMessage.",
+      ),
   })
   .describe(
     "Workspace git integration — auto-commits, enrichment, and LLM-generated commit messages",

package/src/config/skills.ts

@@ -784,6 +784,8 @@ export function loadSkillCatalog(
             toolManifest: detectToolManifest(directory),
             includes: parsed.includes,
             featureFlag: parsed.featureFlag,
+            activationHints: parsed.activationHints,
+            avoidWhen: parsed.avoidWhen,
             inlineCommandExpansions: parsed.inlineCommandExpansions,
           });
         } catch (err) {
@@ -879,6 +881,8 @@ export function loadSkillCatalog(
           toolManifest: detectToolManifest(directory),
           includes: parsed.includes,
           featureFlag: parsed.featureFlag,
+          activationHints: parsed.activationHints,
+          avoidWhen: parsed.avoidWhen,
           inlineCommandExpansions: parsed.inlineCommandExpansions,
         };
 
@@ -1144,7 +1148,7 @@ async function generateSkillIcon(
   name: string,
   description: string,
 ): Promise<string> {
-  const provider = await getConfiguredProvider();
+  const provider = await getConfiguredProvider("skillCategoryInference");
   if (!provider) {
     throw new Error("Configured provider unavailable for icon generation");
   }
@@ -1159,7 +1163,7 @@ async function generateSkillIcon(
     'You are a pixel art icon designer. When asked, return ONLY a single <svg> element — no explanation, no markdown, no code fences. The SVG must be a 16x16 grid pixel art icon using <rect> elements. Use a limited palette (3-5 colors). Keep it under 2KB. The viewBox should be "0 0 16 16" with each pixel being a 1x1 rect.',
     {
       config: {
-        modelIntent: "latency-optimized",
+        callSite: "skillCategoryInference",
         max_tokens: 1024,
       },
     },

package/src/config/types.ts

@@ -37,6 +37,10 @@ export type {
   SlackConfig,
   ThinkingConfig,
   TimeoutConfig,
+  TtsElevenLabsProviderConfig,
+  TtsFishAudioProviderConfig,
+  TtsProviders,
+  TtsService,
   UiConfig,
   WebSearchService,
   WorkspaceGitConfig,

package/src/contacts/contact-store.ts

@@ -1,4 +1,4 @@
-import { and, asc, desc, eq, like, sql } from "drizzle-orm";
+import { and, asc, desc, eq, isNotNull, like, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import { getDb } from "../memory/db.js";
@@ -29,16 +29,27 @@ function escapeLike(value: string): string {
 }
 
 /**
- * Generate a collision-free slugified filename for a contact's per-user persona file.
- * Produces filenames like "alice.md", "alice-2.md", "alice-3.md", etc.
+ * Pure slug transform applied to a display name. No DB lookup, no collision
+ * handling — callers that need a collision-free filename should use
+ * `generateUserFileSlug` instead. Exported so the migration classifier can
+ * recompute the expected base slug for a given display name.
  */
-export function generateUserFileSlug(displayName: string): string {
-  const slug =
+export function computeUserFileBaseSlug(displayName: string): string {
+  return (
     displayName
       .toLowerCase()
       .replace(/[^a-z0-9]+/g, "-")
       .replace(/^-+|-+$/g, "")
-      .slice(0, 100) || "user";
+      .slice(0, 100) || "user"
+  );
+}
+
+/**
+ * Generate a collision-free slugified filename for a contact's per-user persona file.
+ * Produces filenames like "alice.md", "alice-2.md", "alice-3.md", etc.
+ */
+export function generateUserFileSlug(displayName: string): string {
+  const slug = computeUserFileBaseSlug(displayName);
 
   const db = getDb();
   const rows = db
@@ -273,10 +284,27 @@ export function upsertContact(params: {
 
   // Create new contact
   contactId = contactId ?? uuid();
-  const userFileValue =
-    params.userFile !== undefined
-      ? params.userFile
-      : generateUserFileSlug(params.displayName);
+  // Sibling contacts sharing a principal_id must share a user_file so every
+  // channel for one principal resolves to the same persona + journal slug.
+  let resolvedUserFile: string | null;
+  if (params.userFile !== undefined) {
+    resolvedUserFile = params.userFile;
+  } else if (params.principalId) {
+    const sibling = db
+      .select({ userFile: contacts.userFile })
+      .from(contacts)
+      .where(
+        and(
+          eq(contacts.principalId, params.principalId),
+          isNotNull(contacts.userFile),
+        ),
+      )
+      .get();
+    resolvedUserFile =
+      sibling?.userFile ?? generateUserFileSlug(params.displayName);
+  } else {
+    resolvedUserFile = generateUserFileSlug(params.displayName);
+  }
   db.insert(contacts)
     .values({
       id: contactId,
@@ -285,7 +313,7 @@ export function upsertContact(params: {
       role: params.role ?? "contact",
       contactType: params.contactType ?? "human",
       principalId: params.principalId ?? null,
-      userFile: userFileValue ?? null,
+      userFile: resolvedUserFile,
       createdAt: now,
       updatedAt: now,
     })
@@ -811,6 +839,23 @@ export function findContactChannel(params: {
   return null;
 }
 
+/**
+ * Find the guardian contact regardless of channel.
+ * Returns the first contact with role='guardian', or null if none exists.
+ */
+export function findGuardianContact(): ContactWithChannels | null {
+  const db = getDb();
+  const row = db
+    .select()
+    .from(contacts)
+    .where(eq(contacts.role, "guardian"))
+    .orderBy(asc(contacts.createdAt))
+    .limit(1)
+    .get();
+  if (!row) return null;
+  return withChannels(parseContact(row));
+}
+
 /**
  * Find the guardian contact and their specific channel entry for a given channel type.
  * This is the contacts-based equivalent of getGuardianBinding(assistantId, channel).

package/src/contacts/contacts-write.ts

@@ -8,6 +8,8 @@
 
 import type { ChannelId } from "../channels/types.js";
 import type { GuardianBinding } from "../memory/channel-verification-sessions.js";
+import { clearCache as clearTrustCache } from "../permissions/trust-store.js";
+import { ensureGuardianPersonaFile } from "../prompts/persona-resolver.js";
 import { canonicalizeInboundIdentity } from "../util/canonicalize-identity.js";
 import { getLogger } from "../util/logger.js";
 import { emitContactChange } from "./contact-events.js";
@@ -76,7 +78,7 @@ export function createGuardianBinding(params: {
     parseDisplayNameFromMetadata(params.metadataJson) ??
     params.guardianExternalUserId;
 
-  upsertContact({
+  const contact = upsertContact({
     displayName,
     role: "guardian",
     notes: "guardian",
@@ -94,6 +96,35 @@ export function createGuardianBinding(params: {
     ],
   });
 
+  // Seed the per-user persona file so downstream readers (journaling,
+  // persona resolution) can rely on `users/<slug>.md` existing on disk.
+  // Idempotent: pre-existing customized files are preserved.
+  //
+  // Seeding is restricted to the guardian-creation path only — it must
+  // NOT run from inbound-message upsertContactChannel calls, since the
+  // `users/` directory watcher would fire on every new contact and
+  // evict live conversations.
+  if (contact.userFile) {
+    // Tolerate filesystem failures (read-only or full workspace) so a
+    // disk error doesn't leave the DB commit orphaned. The persona file
+    // can be reseeded later; failing the binding here would be worse.
+    try {
+      ensureGuardianPersonaFile(contact.userFile);
+    } catch (err) {
+      log.warn(
+        { err, userFile: contact.userFile },
+        "failed to seed guardian persona file; continuing",
+      );
+    }
+    // Invalidate the trust rule cache so the dynamic guardian-persona
+    // auto-allow rules from `permissions/defaults.ts` are backfilled on
+    // the next `getRules()` call. Without this, guardians created at
+    // runtime (self-heal paths, first-message-seeds-guardian) wouldn't
+    // get their auto-allow rule until the daemon restarts, and the
+    // model would prompt on its first `file_edit users/<slug>.md`.
+    clearTrustCache();
+  }
+
   const now = Date.now();
   const result: GuardianBinding = {
     id: `contact-binding-${params.channel}`,
@@ -210,6 +241,12 @@ export function upsertContactChannel(params: {
     reassignConflictingChannels: !!params.contactId,
   });
 
+  // NOTE: We intentionally do NOT seed `users/<slug>.md` here. This is the
+  // inbound-message hot path — every new contact (Slack, phone, email, etc)
+  // would otherwise fire the `users/` directory watcher in
+  // config-watcher.ts and evict live conversations. Persona-file seeding
+  // is the sole responsibility of `createGuardianBinding`.
+
   const contactResult = findContactChannel({
     channelType: params.sourceChannel,
     externalUserId: canonicalId ?? undefined,

package/src/context/__tests__/compact-prompt.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  loadCompactPrompt,
+  loadCompactPromptOrFallback,
+} from "../window-manager.js";
+
+describe("compact.md prompt asset", () => {
+  test("loads a non-empty prompt string", () => {
+    const prompt = loadCompactPrompt();
+    expect(prompt.length).toBeGreaterThan(0);
+  });
+
+  test("contains the '## Goals' section header (canary for truncation)", () => {
+    const prompt = loadCompactPrompt();
+    expect(prompt).toContain("## Goals");
+  });
+});
+
+describe("loadCompactPromptOrFallback", () => {
+  test("returns loader output when the loader succeeds", () => {
+    const loaded = "custom loaded prompt";
+    const result = loadCompactPromptOrFallback(() => loaded);
+    expect(result).toBe(loaded);
+  });
+
+  test("returns inline fallback when the loader throws", () => {
+    const result = loadCompactPromptOrFallback(() => {
+      throw new Error("compact.md missing");
+    });
+    expect(result.length).toBeGreaterThan(0);
+    expect(result).toContain("## Goals");
+    expect(result).toContain("## Constraints");
+    expect(result).toContain("## Decisions");
+    expect(result).toContain("## Open Conversations");
+    expect(result).toContain("## Key Artifacts");
+    expect(result).toContain("## Recent Progress");
+  });
+
+  test("uses loadCompactPrompt as the default loader", () => {
+    const result = loadCompactPromptOrFallback();
+    expect(result.length).toBeGreaterThan(0);
+    expect(result).toContain("## Goals");
+  });
+});