@vellumai/assistant 0.6.5 → 0.6.6

package/src/config/schemas/conversations.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+
+export const ConversationsConfigSchema = z
+  .object({
+    skipAutoRetitling: z
+      .boolean({
+        error: "conversations.skipAutoRetitling must be a boolean",
+      })
+      .default(false)
+      .describe(
+        "When true, skip the second-pass title regeneration that fires after the third user turn. The initial auto-generated title and manual renames are unaffected.",
+      ),
+  })
+  .describe("Conversation behavior configuration");
+
+export type ConversationsConfig = z.infer<typeof ConversationsConfigSchema>;

package/src/config/schemas/llm.ts

@@ -57,8 +57,6 @@ export const LLMCallSiteEnum = z.enum([
   "guardianQuestionCopy",
   "approvalCopy",
   "approvalConversation",
-  "watchCommentary",
-  "watchSummary",
   "interactionClassifier",
   "styleAnalyzer",
   "inviteInstructionGenerator",
@@ -66,6 +64,7 @@ export const LLMCallSiteEnum = z.enum([
   "meetConsentMonitor",
   "meetChatOpportunity",
   "inference",
+  "feedEventCopy",
 ]);
 export type LLMCallSite = z.infer<typeof LLMCallSiteEnum>;
 
@@ -244,7 +243,7 @@ export type PricingOverride = z.infer<typeof PricingOverrideSchema>;
  */
 export const LLMConfigBase = z.object({
   provider: LLMProvider.default("anthropic"),
-  model: ModelSchema.default("claude-opus-4-7"),
+  model: ModelSchema.default("claude-sonnet-4-6"),
   maxTokens: MaxTokensSchema.default(64000),
   effort: EffortEnum.default("max"),
   speed: SpeedEnum.default("standard"),

package/src/config/schemas/security.ts

@@ -89,25 +89,25 @@ export const PermissionsConfigSchema = z
       ),
     autoApproveUpTo: z
       .union([
-        z.enum(["none", "low", "medium"], {
+        z.enum(["none", "low", "medium", "high"], {
           error:
-            "permissions.autoApproveUpTo must be one of: none, low, medium",
+            "permissions.autoApproveUpTo must be one of: none, low, medium, high",
         }),
         z.object({
           conversation: z
-            .enum(["none", "low", "medium"])
+            .enum(["none", "low", "medium", "high"])
             .default("low")
             .describe(
               "Threshold for interactive conversation sessions (default: low)",
             ),
           background: z
-            .enum(["none", "low", "medium"])
+            .enum(["none", "low", "medium", "high"])
             .default("medium")
             .describe(
               "Threshold for non-interactive guardian sessions (default: medium)",
             ),
           headless: z
-            .enum(["none", "low", "medium"])
+            .enum(["none", "low", "medium", "high"])
             .default("none")
             .describe(
               "Threshold for non-interactive non-guardian sessions (default: none)",
@@ -117,7 +117,7 @@ export const PermissionsConfigSchema = z
       .default({ conversation: "low", background: "medium", headless: "none" })
       .describe(
         "Auto-approve tools at or below this risk level without prompting. " +
-          "Accepts a scalar ('none', 'low', 'medium') applied to all contexts, " +
+          "Accepts a scalar ('none', 'low', 'medium', 'high') applied to all contexts, " +
           "or an object with per-context overrides: { conversation, background, headless }.",
       ),
   })

package/src/config/schemas/tts.ts

@@ -182,6 +182,7 @@ export const TtsXaiProviderConfigSchema = z
       .string({
         error: "services.tts.providers.xai.language must be a string",
       })
+      .transform((v) => v || "auto")
       .default("auto")
       .describe(
         "BCP-47 language code (e.g. 'en-US') or 'auto' for auto-detection",
@@ -250,6 +251,16 @@ for (const id of VALID_TTS_PROVIDERS) {
     );
   }
 }
+const catalogKeys = new Set<string>(VALID_TTS_PROVIDERS);
+for (const id of schemaKeys) {
+  if (!catalogKeys.has(id)) {
+    throw new Error(
+      `TTS provider "${id}" has a schema entry in TtsProvidersSchema but ` +
+        `is not registered in the provider catalog. Add it to ` +
+        `provider-catalog.ts or remove it from TtsProvidersSchema.`,
+    );
+  }
+}
 
 /**
  * Canonical TTS service configuration.

package/src/config/skill-state.ts

@@ -54,8 +54,12 @@ export function resolveSkillStates(
     if (entry && typeof entry.enabled === "boolean") {
       isEnabled = entry.enabled;
     } else {
-      // Default: bundled and managed (user-installed) skills are enabled, others are disabled
-      isEnabled = skill.source === "bundled" || skill.source === "managed";
+      // Default: bundled, managed (user-installed), and plugin-contributed
+      // skills are enabled. Others (workspace, extra) are disabled by default.
+      isEnabled =
+        skill.source === "bundled" ||
+        skill.source === "managed" ||
+        skill.source === "plugin";
     }
 
     if (!isEnabled) {

package/src/config/skills.ts

@@ -18,6 +18,10 @@ import {
 
 import { z } from "zod";
 
+import {
+  getPluginContributedSkillDefinition,
+  getPluginContributedSkillSummaries,
+} from "../plugins/plugin-skill-contributions.js";
 import {
   extractAllText,
   getConfiguredProvider,
@@ -59,7 +63,24 @@ const SkillMetadataSchema = z
   })
   .passthrough();
 
-export type SkillSource = "bundled" | "managed" | "workspace" | "extra";
+/**
+ * Origin of a skill in the merged catalog.
+ *
+ * - `bundled`: ships inside the assistant binary under `bundled-skills/`.
+ * - `managed`: installed into `~/.vellum/workspace/skills/` from our catalog.
+ * - `workspace`: user-authored skill living in a conversation's working dir.
+ * - `extra`: third-party directory roots passed via `loadSkillCatalog`'s
+ *   `extraDirs` argument (primarily for tests).
+ * - `plugin`: contributed at runtime by a loaded plugin via
+ *   `PluginSkillRegistration`. Body is held in-memory by
+ *   `plugins/plugin-skill-contributions.ts`, not on disk.
+ */
+export type SkillSource =
+  | "bundled"
+  | "managed"
+  | "workspace"
+  | "extra"
+  | "plugin";
 
 // ─── Core interfaces ─────────────────────────────────────────────────────────
 
@@ -819,6 +840,37 @@ export function loadSkillCatalog(
     catalog.push(skill);
   }
 
+  // Load plugin-contributed skills. They sit above bundled/extra but below
+  // managed and workspace so that user-authored filesystem skills can
+  // override a plugin-provided skill by declaring the same id under
+  // `~/.vellum/workspace/skills/`. Registration is owned by the plugin
+  // bootstrap — this call is a pure read against the in-memory registry.
+  const pluginSkills = getPluginContributedSkillSummaries();
+  for (const skill of pluginSkills) {
+    if (seenIds.has(skill.id)) {
+      const existingIndex = catalog.findIndex((s) => s.id === skill.id);
+      if (
+        existingIndex !== -1 &&
+        (catalog[existingIndex].source === "bundled" ||
+          catalog[existingIndex].source === "extra")
+      ) {
+        log.info(
+          { id: skill.id, pluginSkill: true },
+          "Plugin skill overrides bundled/extra skill",
+        );
+        catalog[existingIndex] = skill;
+        continue;
+      }
+      log.warn(
+        { id: skill.id },
+        "Skipping duplicate plugin skill id (already present in catalog)",
+      );
+      continue;
+    }
+    seenIds.add(skill.id);
+    catalog.push(skill);
+  }
+
   // Load managed (user) skills, which take precedence over bundled skills with the same ID
   const skillsDir = getSkillsDir();
   const indexedDirectories = getIndexedSkillDirectories(skillsDir);
@@ -829,16 +881,24 @@ export function loadSkillCatalog(
     if (!skill) continue;
 
     if (seenIds.has(skill.id)) {
-      // If the existing entry is bundled, the user skill overrides it
+      // If the existing entry is bundled, extra, or plugin-contributed, the
+      // user skill overrides it. Only another `managed` or `workspace` entry
+      // (already at or above managed precedence) is treated as a true
+      // duplicate.
       const existingIndex = catalog.findIndex((s) => s.id === skill.id);
       if (
         existingIndex !== -1 &&
         (catalog[existingIndex].bundled ||
-          catalog[existingIndex].source === "extra")
+          catalog[existingIndex].source === "extra" ||
+          catalog[existingIndex].source === "plugin")
       ) {
         log.info(
-          { id: skill.id, directory },
-          "User skill overrides bundled skill",
+          {
+            id: skill.id,
+            directory,
+            overriding: catalog[existingIndex].source,
+          },
+          "User skill overrides existing catalog entry",
         );
         catalog[existingIndex] = skillSummaryFromDefinition(skill, "managed");
         continue;
@@ -1018,6 +1078,35 @@ export function listReferenceFiles(directoryPath: string): string | null {
 }
 
 function loadSkillDefinition(skill: SkillSummary): SkillLookupResult {
+  // Plugin-contributed skills live in-memory, not on disk. The registry
+  // (see `plugins/plugin-skill-contributions.ts`) stores a pre-built
+  // SkillDefinition we can return directly — no file read, no frontmatter
+  // parse. We still run placeholder / feature-gate substitution on the
+  // body so plugin skills behave the same as filesystem skills from the
+  // model's perspective.
+  if (skill.source === "plugin") {
+    const pluginDef = getPluginContributedSkillDefinition(skill.id);
+    if (!pluginDef) {
+      // The skill was in the catalog when the selector ran but has since
+      // been unregistered (plugin hot-reload, shutdown race). Fail loudly
+      // rather than returning a mystery undefined.
+      return {
+        error: `Plugin-contributed skill "${skill.id}" is no longer registered`,
+      };
+    }
+    // Shallow-clone so mutating the returned `body` below does not touch
+    // the registry's stored copy — the registry must stay the source of
+    // truth across repeated `skill_load` calls.
+    const loaded: SkillDefinition = { ...pluginDef };
+    loaded.body = loaded.body.replaceAll("{baseDir}", loaded.directoryPath);
+    loaded.body = loaded.body.replaceAll(
+      "{workspaceDir}",
+      getWorkspaceDirDisplay(),
+    );
+    loaded.body = applyFeatureGatedSections(loaded.body);
+    return { skill: loaded };
+  }
+
   let loaded: SkillDefinition | null;
   if (skill.bundled) {
     loaded = readBundledSkillFromDirectory(skill.directoryPath);

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

@@ -11,9 +11,26 @@ describe("compact.md prompt asset", () => {
     expect(prompt.length).toBeGreaterThan(0);
   });
 
-  test("contains the '## Goals' section header (canary for truncation)", () => {
+  test("contains explicit length target (canary against accidental 'concise' reversion)", () => {
     const prompt = loadCompactPrompt();
-    expect(prompt).toContain("## Goals");
+    expect(prompt).toContain("1500");
+    expect(prompt).toContain("4000");
+    expect(prompt.toLowerCase()).toContain("tokens");
+  });
+
+  test("includes the never-include guidance for injection tags", () => {
+    const prompt = loadCompactPrompt();
+    expect(prompt).toContain("<memory");
+    expect(prompt).toContain("<turn_context>");
+    expect(prompt.toLowerCase()).toContain("never include");
+  });
+
+  test("lists the flexible section headers", () => {
+    const prompt = loadCompactPrompt();
+    expect(prompt).toContain("## What We're Working On");
+    expect(prompt).toContain("## Decisions & Commitments");
+    expect(prompt).toContain("## Facts Worth Remembering");
+    expect(prompt).toContain("## Open Threads");
   });
 });
 
@@ -29,17 +46,18 @@ describe("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");
+    // Fallback must carry the same core guidance as the on-disk prompt so
+    // summary quality doesn't silently collapse when the bundled asset is
+    // missing (partial deploys, filesystem corruption).
+    expect(result).toContain("1500");
+    expect(result).toContain("4000");
+    expect(result).toContain("<memory");
+    expect(result.toLowerCase()).toContain("never include");
   });
 
   test("uses loadCompactPrompt as the default loader", () => {
     const result = loadCompactPromptOrFallback();
     expect(result.length).toBeGreaterThan(0);
-    expect(result).toContain("## Goals");
+    expect(result).toContain("1500");
   });
 });

package/src/context/prompts/compact.md

@@ -1,12 +1,26 @@
-You compress long assistant conversations into durable working memory.
-Focus on actionable state, not prose.
-Preserve concrete facts: goals, constraints, decisions, pending questions, file paths, commands, errors, and TODOs.
-Remove repetition and stale details that were superseded.
-Thread anchors: when a "Retained Thread References" section is present, each listed reply cites its parent via `→ Mxxxxxx`. If that parent appears in the Transcript, preserve its text verbatim (reactions may be aggregated as "N users reacted"). Omit when the section is absent.
-Return concise markdown using these section headers exactly:
-## Goals
-## Constraints
-## Decisions
-## Open Conversations
-## Key Artifacts
-## Recent Progress
+You are summarizing a long conversation so that the assistant can keep working with it after older messages are dropped. Your summary will REPLACE those messages — the assistant's only access to what was said earlier will be what you write here.
+
+Be thorough. Capture what happened, why it mattered, what's unresolved, and what was felt. Do not compress away emotional tone, relationship context, or nuance. Keep specific details (names, numbers, file paths, commands, URLs, exact phrasings) when they might matter later.
+
+Target length: aim for 1500–4000 tokens. Use the upper end of that range when the conversation is rich in decisions, relationships, emotional content, or threads that are still open. Use the lower end when the conversation is short or a simple task execution.
+
+Open with a 1–2 paragraph narrative describing what the conversation is about and where it currently stands. Then use `## ` section headers. Use these headers when they apply; skip sections that have nothing to say; add your own headers when something important doesn't fit:
+
+- `## What We're Working On` — active tasks, projects, intentions
+- `## Decisions & Commitments` — what was decided, what was promised, by whom
+- `## Facts Worth Remembering` — durable details: names, preferences, constraints, background
+- `## Open Threads` — unresolved questions, pending follow-ups, things the user is still thinking about
+- `## Emotional Arc / Relationship Notes` — tone, feelings expressed, relational context (include when relevant; omit otherwise)
+- `## Artifacts & References` — files, URLs, commands, code snippets, external systems referenced
+
+If an existing summary is provided, update it: merge new information in, prefer the most recent and explicit detail on conflicts, and preserve anything that is still unresolved or still true. Do not restart from scratch.
+
+**Never include in the summary:**
+
+- Content inside `<memory __injected>`, `<memory>`, `<turn_context>`, `<workspace>`, `<knowledge_base>`, `<system_reminder>`, `<now_scratchpad>`, `<NOW.md …>`, `<active_thread>`, `<channel_capabilities>`, `<transport_hints>`, `<system_notice>`, or any other angle-bracket-tagged system blocks. These are system metadata attached to messages, not part of what the user or assistant said. Ignore them entirely.
+- Tool-call boilerplate (retries, failed attempts the assistant recovered from, routine status updates). Summarize the *outcome* instead.
+- Repetitive chit-chat that adds nothing to working memory.
+
+**Thread anchors (Slack only):** if the input includes a "Retained Thread References" section, each listed reply cites its parent via `→ Mxxxxxx`. If that parent message appears in the transcript, preserve its text verbatim in the summary (reactions may be aggregated as "N users reacted"). Omit this entirely when no such section is present.
+
+Return only the summary itself in markdown — no preamble, no meta-commentary about what you're doing.

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

@@ -70,72 +70,12 @@ export function calculateMaxToolResultChars(
   );
 }
 
-/**
- * Check whether a tool-result content block exceeds the computed character
- * budget for the given context window.
- */
-export function isOversizedToolResult(
-  block: ToolResultContent,
-  contextWindowTokens: number,
-): boolean {
-  if (typeof block.content !== "string") {
-    return false;
-  }
-  const maxChars = calculateMaxToolResultChars(contextWindowTokens);
-  return block.content.length > maxChars;
-}
-
-/**
- * If the tool-result block is oversized, return a shallow copy with its
- * `.content` truncated. Otherwise return the block unchanged.
- */
-export function truncateToolResultBlock(
-  block: ToolResultContent,
-  contextWindowTokens: number,
-): ToolResultContent {
-  const maxChars = calculateMaxToolResultChars(contextWindowTokens);
-  if (block.content.length <= maxChars) {
-    return block;
-  }
-  return {
-    ...block,
-    content: truncateToolResultText(block.content, maxChars),
-  };
-}
-
-/**
- * Map over an array of content blocks, truncating any oversized tool results.
- * Returns a new array and the number of blocks that were truncated.
- */
-export function truncateOversizedToolResults(
-  blocks: ContentBlock[],
-  contextWindowTokens: number,
-): { blocks: ContentBlock[]; truncatedCount: number } {
-  let truncatedCount = 0;
-
-  const mapped = blocks.map((block) => {
-    if (block.type !== "tool_result") {
-      return block;
-    }
-    const toolBlock = block as ToolResultContent;
-    if (isOversizedToolResult(toolBlock, contextWindowTokens)) {
-      truncatedCount++;
-      return truncateToolResultBlock(toolBlock, contextWindowTokens);
-    }
-    return block;
-  });
-
-  return { blocks: mapped, truncatedCount };
-}
-
 /**
  * Aggressively truncate all tool-result text across an entire message history.
  *
- * Unlike `truncateOversizedToolResults` (which operates on a flat block array
- * for a single turn), this walks every message and truncates tool_result
- * `.content` strings that exceed `maxChars`. This is used during overflow
- * recovery where we need to shrink the overall payload, not just individual
- * oversized results.
+ * Walks every message and truncates tool_result `.content` strings that
+ * exceed `maxChars`. Used during overflow recovery where we need to shrink
+ * the overall payload, not just individual oversized results.
  */
 export function truncateToolResultsAcrossHistory(
   messages: Message[],