@vellumai/assistant 0.6.3 → 0.6.4

package/src/config/schemas/services.ts

@@ -1,5 +1,8 @@
 import { z } from "zod";
 
+import { SttServiceSchema } from "./stt.js";
+import { TtsServiceSchema } from "./tts.js";
+
 export const ServiceModeSchema = z.enum(["managed", "your-own"]);
 export type ServiceMode = z.infer<typeof ServiceModeSchema>;
 
@@ -66,6 +69,16 @@ export const GitHubOAuthServiceSchema = BaseServiceSchema.extend({
 });
 export type GitHubOAuthService = z.infer<typeof GitHubOAuthServiceSchema>;
 
+export const NotionOAuthServiceSchema = BaseServiceSchema.extend({
+  mode: ServiceModeSchema.default("your-own"),
+});
+export type NotionOAuthService = z.infer<typeof NotionOAuthServiceSchema>;
+
+export const TwitterOAuthServiceSchema = BaseServiceSchema.extend({
+  mode: ServiceModeSchema.default("your-own"),
+});
+export type TwitterOAuthService = z.infer<typeof TwitterOAuthServiceSchema>;
+
 export const ServicesSchema = z.object({
   inference: InferenceServiceSchema.default(InferenceServiceSchema.parse({})),
   "image-generation": ImageGenerationServiceSchema.default(
@@ -74,6 +87,12 @@ export const ServicesSchema = z.object({
   "web-search": WebSearchServiceSchema.default(
     WebSearchServiceSchema.parse({}),
   ),
+  stt: SttServiceSchema.default({
+    mode: "your-own" as const,
+    provider: "deepgram" as const,
+    providers: {},
+  }),
+  tts: TtsServiceSchema.default(TtsServiceSchema.parse({})),
   "google-oauth": GoogleOAuthServiceSchema.default(
     GoogleOAuthServiceSchema.parse({}),
   ),
@@ -86,5 +105,30 @@ export const ServicesSchema = z.object({
   "github-oauth": GitHubOAuthServiceSchema.default(
     GitHubOAuthServiceSchema.parse({}),
   ),
+  "notion-oauth": NotionOAuthServiceSchema.default(
+    NotionOAuthServiceSchema.parse({}),
+  ),
+  "twitter-oauth": TwitterOAuthServiceSchema.default(
+    TwitterOAuthServiceSchema.parse({}),
+  ),
 });
 export type Services = z.infer<typeof ServicesSchema>;
+
+/**
+ * Safely read the `mode` of a `services.*` entry.
+ *
+ * Most service entries (OAuth providers, inference, etc.) extend
+ * `BaseServiceSchema` and therefore carry a `mode: "managed" | "your-own"`
+ * field.
+ *
+ * Returns `undefined` when the requested service entry has no `mode` field,
+ * so callers can treat those entries as implicitly "your-own" without the
+ * compiler tripping on a union widened by non-BaseService members.
+ */
+export function getServiceMode(
+  services: Services,
+  key: keyof Services,
+): ServiceMode | undefined {
+  const entry = services[key] as { mode?: ServiceMode };
+  return entry.mode;
+}

package/src/config/schemas/stt.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+
+/**
+ * Valid STT provider identifiers. New providers append here and register
+ * an adapter.
+ */
+export const VALID_STT_PROVIDERS = [
+  "deepgram",
+  "google-gemini",
+  "openai-whisper",
+] as const;
+
+/**
+ * Sparse provider config map under `services.stt.providers`.
+ *
+ * This is a forward-compatible record that accepts any provider ID as key
+ * with an object value. All provider entries — known (`openai-whisper`,
+ * `deepgram`, `google-gemini`) and unknown — are accepted with generic object
+ * validation. Adding a new provider ID does not require a migration to seed
+ * `services.stt.providers.<id>`.
+ *
+ * The map only holds entries the user has explicitly configured — it is
+ * NOT required to enumerate every known provider.
+ */
+export const SttProvidersSchema = z.record(
+  z.string(),
+  z.record(z.string(), z.unknown()).default({}),
+);
+export type SttProviders = z.infer<typeof SttProvidersSchema>;
+
+/**
+ * Canonical STT service configuration.
+ *
+ * `mode` is locked to `"your-own"` -- managed STT is not supported.
+ * Attempting to set `mode: "managed"` will fail schema validation.
+ */
+export const SttServiceSchema = z
+  .object({
+    mode: z
+      .literal("your-own", {
+        error:
+          'services.stt.mode must be "your-own" -- managed STT is not supported',
+      })
+      .default("your-own" as const)
+      .describe(
+        'STT service mode -- only "your-own" is supported (managed STT is not available)',
+      ),
+    provider: z
+      .enum(VALID_STT_PROVIDERS, {
+        error: `services.stt.provider must be one of: ${VALID_STT_PROVIDERS.join(", ")}`,
+      })
+      .describe("Active STT provider used for speech-to-text transcription"),
+    providers: SttProvidersSchema.default({}),
+  })
+  .describe(
+    "Speech-to-text service configuration -- provider selection and per-provider settings",
+  );
+
+export type SttService = z.infer<typeof SttServiceSchema>;

package/src/config/schemas/tts.ts

@@ -0,0 +1,230 @@
+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 TtsProvidersSchema = z.object({
+  elevenlabs: TtsElevenLabsProviderConfigSchema.default(
+    TtsElevenLabsProviderConfigSchema.parse({}),
+  ),
+  "fish-audio": TtsFishAudioProviderConfigSchema.default(
+    TtsFishAudioProviderConfigSchema.parse({}),
+  ),
+  deepgram: TtsDeepgramProviderConfigSchema.default(
+    TtsDeepgramProviderConfigSchema.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 the release update bulletin (UPDATES.md) is materialized into the workspace on daemon startup",
+      ),
+  })
+  .describe("Release update bulletin configuration");
+
+export type UpdatesConfig = z.infer<typeof UpdatesConfigSchema>;

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,
         };
 

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/post-turn-tool-result-truncation.ts

@@ -8,6 +8,7 @@ import type {
   ToolResultContent,
   ToolUseContent,
 } from "../providers/types.js";
+import { safeStringSlice } from "../util/unicode.js";
 
 /** Minimum content length (chars) before a tool result is eligible for truncation. ~2000 tokens at 4 chars/token. */
 export const THRESHOLD_CHARS = 8_000;
@@ -43,8 +44,8 @@ export function buildTruncatedContent(
   filePath: string,
 ): string {
   const half = Math.floor(TARGET_CHARS / 2);
-  const prefix = original.slice(0, half);
-  const suffix = original.slice(-half);
+  const prefix = safeStringSlice(original, 0, half);
+  const suffix = safeStringSlice(original, original.length - half, original.length);
   const omittedChars = original.length - TARGET_CHARS;
   const estimatedTokens = Math.round(omittedChars / 4);
   return `${prefix}\n\n...(${estimatedTokens} tokens omitted ${TRUNCATION_MARKER} ${filePath})\n\n${suffix}`;

package/src/context/tool-result-truncation.ts

@@ -3,6 +3,7 @@ import type {
   Message,
   ToolResultContent,
 } from "../providers/types.js";
+import { safeStringSlice } from "../util/unicode.js";
 
 /**
  * Maximum share of the context window that a single tool result may occupy.
@@ -53,7 +54,7 @@ export function truncateToolResultText(text: string, maxChars: number): string {
     return text;
   }
 
-  return text.slice(0, sliceEnd) + TRUNCATION_SUFFIX;
+  return safeStringSlice(text, 0, sliceEnd) + TRUNCATION_SUFFIX;
 }
 
 /**