@vellumai/assistant 0.6.2 → 0.6.4

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

@@ -27,7 +27,6 @@ export type {
   PermissionsConfig,
   QdrantConfig,
   RateLimitConfig,
-  SandboxConfig,
   SecretDetectionConfig,
   ServiceMode,
   Services,
@@ -38,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

@@ -0,0 +1,177 @@
+import { createHash } from "node:crypto";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type {
+  ContentBlock,
+  Message,
+  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;
+
+/** Target size (chars) for the truncated stub. ~300 tokens at 4 chars/token. */
+export const TARGET_CHARS = 1_200;
+
+/** Subdirectory name under the conversation directory for saved full results. */
+export const TOOL_RESULT_DIR = ".tool-results";
+
+/** Marker used to detect already-truncated results (idempotency guard). */
+export const TRUNCATION_MARKER = "\u2014 full result:";
+
+/**
+ * Deterministic file path for a tool result's full content on disk.
+ * Uses the first 12 hex chars of the SHA-256 of the tool_use_id.
+ */
+export function getToolResultFilePath(
+  conversationDir: string,
+  toolUseId: string,
+): string {
+  const hash = createHash("sha256").update(toolUseId).digest("hex").slice(0, 12);
+  return join(conversationDir, TOOL_RESULT_DIR, `${hash}.txt`);
+}
+
+/**
+ * Build the truncated stub that replaces a large tool result in context.
+ * Preserves the first and last halves of TARGET_CHARS, with a middle marker
+ * indicating how many tokens were omitted and where to find the full result.
+ */
+export function buildTruncatedContent(
+  original: string,
+  filePath: string,
+): string {
+  const half = Math.floor(TARGET_CHARS / 2);
+  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}`;
+}
+
+/**
+ * Walk all messages and truncate tool results that exceed `THRESHOLD_CHARS`.
+ *
+ * For each eligible result:
+ * - The full content is persisted to a deterministic file path on disk.
+ * - The in-context content is replaced with a prefix/suffix stub.
+ *
+ * Results are skipped if they are below threshold, are error results,
+ * or have already been truncated (contain `TRUNCATION_MARKER`).
+ *
+ * Returns a shallow-copied messages array (only modified messages are cloned)
+ * and the count of results that were truncated.
+ */
+export function postTurnTruncateToolResults(
+  messages: Message[],
+  options: { conversationDir: string },
+): { messages: Message[]; truncatedCount: number } {
+  let truncatedCount = 0;
+
+  const mapped = messages.map((msg) => {
+    let changed = false;
+    const nextContent: ContentBlock[] = msg.content.map((block) => {
+      if (block.type !== "tool_result") return block;
+      const tr = block as ToolResultContent;
+
+      // Skip short results.
+      if (tr.content.length <= THRESHOLD_CHARS) return block;
+
+      // Skip error results.
+      if (tr.is_error) return block;
+
+      // Skip already-truncated results (idempotency).
+      if (tr.content.includes(TRUNCATION_MARKER)) return block;
+
+      const filePath = getToolResultFilePath(
+        options.conversationDir,
+        tr.tool_use_id,
+      );
+
+      // Persist full content to disk.
+      mkdirSync(join(options.conversationDir, TOOL_RESULT_DIR), {
+        recursive: true,
+      });
+      writeFileSync(filePath, tr.content, "utf-8");
+
+      changed = true;
+      truncatedCount++;
+      return {
+        ...tr,
+        content: buildTruncatedContent(tr.content, filePath),
+      } as ContentBlock;
+    });
+
+    return changed ? { ...msg, content: nextContent } : msg;
+  });
+
+  return { messages: truncatedCount > 0 ? mapped : messages, truncatedCount };
+}
+
+/** Stub that replaces a re-read of a saved tool result to avoid context duplication. */
+export const REREAD_STUB =
+  "(Re-read of saved tool result — original context is preserved above)";
+
+/**
+ * Deduplicate re-reads of saved tool results.
+ *
+ * When `postTurnTruncateToolResults` truncates a large result, it saves the full
+ * content to a `.tool-results/` file. If the model later calls `file_read` on that
+ * saved file, the result is a second copy of content whose truncated prefix/suffix
+ * is already in context. This function detects those re-reads and replaces their
+ * tool_result content with a short stub to avoid duplication.
+ */
+export function derefToolResultReReads(messages: Message[]): {
+  messages: Message[];
+  dereferencedCount: number;
+} {
+  // Build a set of tool_use_ids that are file_read calls targeting .tool-results/ paths.
+  const reReadToolUseIds = new Set<string>();
+
+  for (const msg of messages) {
+    if (msg.role !== "assistant") continue;
+    for (const block of msg.content) {
+      if (block.type !== "tool_use") continue;
+      const tu = block as ToolUseContent;
+      if (tu.name !== "file_read") continue;
+      const filePath = tu.input.path ?? tu.input.file_path;
+      if (typeof filePath !== "string") continue;
+      if (filePath.includes(`/${TOOL_RESULT_DIR}/`)) {
+        reReadToolUseIds.add(tu.id);
+      }
+    }
+  }
+
+  if (reReadToolUseIds.size === 0) {
+    return { messages, dereferencedCount: 0 };
+  }
+
+  let dereferencedCount = 0;
+
+  const mapped = messages.map((msg) => {
+    if (msg.role !== "user") return msg;
+
+    let changed = false;
+    const nextContent: ContentBlock[] = msg.content.map((block) => {
+      if (block.type !== "tool_result") return block;
+      const tr = block as ToolResultContent;
+      if (!reReadToolUseIds.has(tr.tool_use_id)) return block;
+
+      // Skip error results — preserve diagnostics (e.g. file not found).
+      if (tr.is_error) return block;
+
+      changed = true;
+      dereferencedCount++;
+      return { ...tr, content: REREAD_STUB } as ContentBlock;
+    });
+
+    return changed ? { ...msg, content: nextContent } : msg;
+  });
+
+  return {
+    messages: dereferencedCount > 0 ? mapped : messages,
+    dereferencedCount,
+  };
+}

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;
 }
 
 /**