@vellumai/assistant 0.5.1 → 0.5.3

package/src/config/raw-config-utils.ts

@@ -28,3 +28,61 @@ export function setServiceField(
   services[service] = svc;
   raw.services = services;
 }
+
+/**
+ * Safely set a nested field on a raw config object's `memory.embeddings` map.
+ *
+ * Ensures the `memory` and `embeddings` objects exist before writing,
+ * so callers don't need to guard against undefined intermediate keys.
+ *
+ * Example: `setMemoryEmbeddingField(raw, "provider", "openai")`
+ * produces `raw.memory.embeddings.provider = "openai"`.
+ */
+export function setMemoryEmbeddingField(
+  raw: Record<string, unknown>,
+  field: string,
+  value: unknown,
+): void {
+  const memory: Record<string, unknown> =
+    raw.memory != null &&
+    typeof raw.memory === "object" &&
+    !Array.isArray(raw.memory)
+      ? (raw.memory as Record<string, unknown>)
+      : {};
+  const existing = memory.embeddings;
+  const embeddings: Record<string, unknown> =
+    existing != null && typeof existing === "object" && !Array.isArray(existing)
+      ? (existing as Record<string, unknown>)
+      : {};
+  embeddings[field] = value;
+  memory.embeddings = embeddings;
+  raw.memory = memory;
+}
+
+/**
+ * Safely delete a nested field from a raw config object's `memory.embeddings`
+ * map, allowing Zod schema defaults to take effect on the next config reload.
+ */
+export function deleteMemoryEmbeddingField(
+  raw: Record<string, unknown>,
+  field: string,
+): void {
+  if (
+    raw.memory == null ||
+    typeof raw.memory !== "object" ||
+    Array.isArray(raw.memory)
+  ) {
+    return;
+  }
+  const memory = raw.memory as Record<string, unknown>;
+  const existing = memory.embeddings;
+  if (
+    existing == null ||
+    typeof existing !== "object" ||
+    Array.isArray(existing)
+  ) {
+    return;
+  }
+  const embeddings = existing as Record<string, unknown>;
+  delete embeddings[field];
+}

package/src/config/schema-utils.ts

@@ -1,8 +1,34 @@
 import type { z } from "zod";
 
+/**
+ * Unwrap a Zod schema to reach its inner object shape, handling:
+ * - default/optional/nullable wrappers (innerType)
+ * - pipe/transform wrappers (in — the input side)
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function unwrapToShape(schema: any): any {
+  let current = schema;
+  while (current && !current.shape) {
+    const def = current._zod?.def;
+    if (!def) break;
+    // Pipe/transform: follow the input side to get the pre-transform schema
+    if (def.type === "pipe" && def.in) {
+      current = def.in;
+      continue;
+    }
+    // Default/optional/nullable: follow innerType
+    if (def.innerType) {
+      current = def.innerType;
+      continue;
+    }
+    break;
+  }
+  return current;
+}
+
 /**
  * Navigate a Zod schema by dotted path, unwrapping wrapper types
- * (default, optional, nullable) to reach inner object shapes.
+ * (default, optional, nullable, pipe/transform) to reach inner object shapes.
  * Returns the Zod schema at the given path, or null if the path is invalid.
  */
 export function getSchemaAtPath(
@@ -13,12 +39,7 @@ export function getSchemaAtPath(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   let current: any = schema;
   for (const key of keys) {
-    // Unwrap default/optional/nullable wrappers to find inner object shape
-    while (current && !current.shape) {
-      const inner = current._zod?.def?.innerType;
-      if (!inner) break;
-      current = inner;
-    }
+    current = unwrapToShape(current);
     if (!current || !current.shape) return null;
     current = current.shape[key];
     if (!current) return null;

package/src/config/schema.ts

@@ -38,6 +38,7 @@ export type { ElevenLabsConfig } from "./schemas/elevenlabs.js";
 export {
   DEFAULT_ELEVENLABS_VOICE_ID,
   ElevenLabsConfigSchema,
+  VALID_CONVERSATION_TIMEOUTS,
 } from "./schemas/elevenlabs.js";
 export type { HeartbeatConfig } from "./schemas/heartbeat.js";
 export { HeartbeatConfigSchema } from "./schemas/heartbeat.js";
@@ -105,6 +106,18 @@ export {
   MemoryDynamicBudgetConfigSchema,
   MemoryRetrievalConfigSchema,
 } from "./schemas/memory-retrieval.js";
+export type {
+  MemorySimplifiedArchiveRecallConfig,
+  MemorySimplifiedBriefConfig,
+  MemorySimplifiedConfig,
+  MemorySimplifiedReducerConfig,
+} from "./schemas/memory-simplified.js";
+export {
+  MemorySimplifiedArchiveRecallConfigSchema,
+  MemorySimplifiedBriefConfigSchema,
+  MemorySimplifiedConfigSchema,
+  MemorySimplifiedReducerConfigSchema,
+} from "./schemas/memory-simplified.js";
 export type {
   MemoryEmbeddingsConfig,
   MemorySegmentationConfig,
@@ -321,6 +334,13 @@ export const AssistantConfigSchema = z
       .boolean()
       .default(true)
       .describe("Whether to send diagnostic/crash reports"),
+    maxStepsPerSession: z
+      .number({ error: "maxStepsPerSession must be a number" })
+      .int("maxStepsPerSession must be an integer")
+      .min(1, "maxStepsPerSession must be >= 1")
+      .max(200, "maxStepsPerSession must be <= 200")
+      .default(50)
+      .describe("Maximum number of computer-use steps per session"),
   })
   .superRefine((config, ctx) => {
     if (

package/src/config/schemas/elevenlabs.ts

@@ -5,6 +5,9 @@ import { z } from "zod";
 // Mirrored in: clients/macos/.../OpenAIVoiceService.swift (defaultVoiceId)
 export const DEFAULT_ELEVENLABS_VOICE_ID = "ZF6FPAbjXT4488VcRRnw";
 
+/** Valid conversation timeout values (seconds). Shared with voice-config-update tool. */
+export const VALID_CONVERSATION_TIMEOUTS = [5, 10, 15, 30, 60] as const;
+
 export const ElevenLabsConfigSchema = z
   .object({
     voiceId: z
@@ -42,6 +45,21 @@ export const ElevenLabsConfigSchema = z
       .describe(
         "How closely the output matches the original voice — higher values increase similarity",
       ),
+    conversationTimeoutSeconds: z
+      .number({
+        error: "elevenlabs.conversationTimeoutSeconds must be a number",
+      })
+      .refine(
+        (v) =>
+          VALID_CONVERSATION_TIMEOUTS.includes(
+            v as (typeof VALID_CONVERSATION_TIMEOUTS)[number],
+          ),
+        {
+          message: `elevenlabs.conversationTimeoutSeconds must be one of: ${VALID_CONVERSATION_TIMEOUTS.join(", ")}`,
+        },
+      )
+      .default(30)
+      .describe("Seconds of silence before voice conversation auto-ends"),
   })
   .describe("ElevenLabs text-to-speech configuration");
 

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

@@ -68,8 +68,10 @@ export const MemoryCleanupConfigSchema = z
       .nonnegative(
         "memory.cleanup.conversationRetentionDays must be non-negative",
       )
-      .default(90)
-      .describe("Number of days to retain conversation data before cleanup"),
+      .default(0)
+      .describe(
+        "Number of days to retain conversation data before cleanup (0 disables pruning)",
+      ),
   })
   .describe("Automatic memory cleanup and garbage collection settings");
 

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

@@ -0,0 +1,101 @@
+import { z } from "zod";
+
+export const MemorySimplifiedBriefConfigSchema = z
+  .object({
+    maxTokens: z
+      .number({
+        error: "memory.simplified.brief.maxTokens must be a number",
+      })
+      .int("memory.simplified.brief.maxTokens must be an integer")
+      .positive("memory.simplified.brief.maxTokens must be a positive integer")
+      .default(4000)
+      .describe(
+        "Maximum token budget for the memory brief injected into conversation context",
+      ),
+  })
+  .describe("Controls the memory brief that is injected into conversations");
+
+export const MemorySimplifiedReducerConfigSchema = z
+  .object({
+    idleDelayMs: z
+      .number({
+        error: "memory.simplified.reducer.idleDelayMs must be a number",
+      })
+      .int("memory.simplified.reducer.idleDelayMs must be an integer")
+      .positive(
+        "memory.simplified.reducer.idleDelayMs must be a positive integer",
+      )
+      .default(30_000)
+      .describe(
+        "Milliseconds of idle time before the reducer processes new conversation turns into memory",
+      ),
+    switchWaitMs: z
+      .number({
+        error: "memory.simplified.reducer.switchWaitMs must be a number",
+      })
+      .int("memory.simplified.reducer.switchWaitMs must be an integer")
+      .positive(
+        "memory.simplified.reducer.switchWaitMs must be a positive integer",
+      )
+      .default(5_000)
+      .describe(
+        "Milliseconds to wait after a conversation switch before running the reducer",
+      ),
+  })
+  .describe(
+    "Controls when the memory reducer runs to process conversation turns into persistent memory",
+  );
+
+export const MemorySimplifiedArchiveRecallConfigSchema = z
+  .object({
+    maxSnippets: z
+      .number({
+        error: "memory.simplified.archiveRecall.maxSnippets must be a number",
+      })
+      .int("memory.simplified.archiveRecall.maxSnippets must be an integer")
+      .positive(
+        "memory.simplified.archiveRecall.maxSnippets must be a positive integer",
+      )
+      .default(10)
+      .describe(
+        "Maximum number of archive snippets to recall when supplementing the brief with semantic search",
+      ),
+  })
+  .describe(
+    "Controls how archived memory snippets are recalled via semantic search",
+  );
+
+export const MemorySimplifiedConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({
+        error: "memory.simplified.enabled must be a boolean",
+      })
+      .default(false)
+      .describe("Whether the simplified memory system is enabled"),
+    brief: MemorySimplifiedBriefConfigSchema.default(
+      MemorySimplifiedBriefConfigSchema.parse({}),
+    ),
+    reducer: MemorySimplifiedReducerConfigSchema.default(
+      MemorySimplifiedReducerConfigSchema.parse({}),
+    ),
+    archiveRecall: MemorySimplifiedArchiveRecallConfigSchema.default(
+      MemorySimplifiedArchiveRecallConfigSchema.parse({}),
+    ),
+  })
+  .describe(
+    "Simplified two-layer memory system — a brief plus archive recall, replacing the legacy item/tier/staleness model",
+  );
+
+export type MemorySimplifiedConfig = z.infer<
+  typeof MemorySimplifiedConfigSchema
+>;
+export type MemorySimplifiedBriefConfig = z.infer<
+  typeof MemorySimplifiedBriefConfigSchema
+>;
+export type MemorySimplifiedReducerConfig = z.infer<
+  typeof MemorySimplifiedReducerConfigSchema
+>;
+export type MemorySimplifiedArchiveRecallConfig = z.infer<
+  typeof MemorySimplifiedArchiveRecallConfigSchema
+>;

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-const VALID_MEMORY_EMBEDDING_PROVIDERS = [
+export const VALID_MEMORY_EMBEDDING_PROVIDERS = [
   "auto",
   "local",
   "openai",

package/src/config/schemas/memory.ts

@@ -10,6 +10,7 @@ import {
   MemorySummarizationConfigSchema,
 } from "./memory-processing.js";
 import { MemoryRetrievalConfigSchema } from "./memory-retrieval.js";
+import { MemorySimplifiedConfigSchema } from "./memory-simplified.js";
 import {
   MemoryEmbeddingsConfigSchema,
   MemorySegmentationConfigSchema,
@@ -45,6 +46,9 @@ export const MemoryConfigSchema = z
     summarization: MemorySummarizationConfigSchema.default(
       MemorySummarizationConfigSchema.parse({}),
     ),
+    simplified: MemorySimplifiedConfigSchema.default(
+      MemorySimplifiedConfigSchema.parse({}),
+    ),
   })
   .describe(
     "Long-term memory system — stores, retrieves, and manages persistent knowledge across conversations",

package/src/config/schemas/services.ts

@@ -20,15 +20,18 @@ export const VALID_WEB_SEARCH_PROVIDERS = [
   "inference-provider-native",
 ] as const;
 
-export const InferenceServiceSchema = z.object({
+export const BaseServiceSchema = z.object({
   mode: ServiceModeSchema.default("your-own"),
+});
+export type BaseService = z.infer<typeof BaseServiceSchema>;
+
+export const InferenceServiceSchema = BaseServiceSchema.extend({
   provider: z.enum(VALID_INFERENCE_PROVIDERS).default("anthropic"),
   model: z.string().default("claude-opus-4-6"),
 });
 export type InferenceService = z.infer<typeof InferenceServiceSchema>;
 
-export const ImageGenerationServiceSchema = z.object({
-  mode: ServiceModeSchema.default("your-own"),
+export const ImageGenerationServiceSchema = BaseServiceSchema.extend({
   provider: z.enum(VALID_IMAGE_GEN_PROVIDERS).default("gemini"),
   model: z.string().default("gemini-3.1-flash-image-preview"),
 });
@@ -36,15 +39,14 @@ export type ImageGenerationService = z.infer<
   typeof ImageGenerationServiceSchema
 >;
 
-export const WebSearchServiceSchema = z.object({
-  mode: ServiceModeSchema.default("your-own"),
+export const WebSearchServiceSchema = BaseServiceSchema.extend({
   provider: z
     .enum(VALID_WEB_SEARCH_PROVIDERS)
     .default("inference-provider-native"),
 });
 export type WebSearchService = z.infer<typeof WebSearchServiceSchema>;
 
-export const GoogleOAuthServiceSchema = z.object({
+export const GoogleOAuthServiceSchema = BaseServiceSchema.extend({
   mode: ServiceModeSchema.default("managed"),
 });
 export type GoogleOAuthService = z.infer<typeof GoogleOAuthServiceSchema>;

package/src/config/skills.ts

@@ -25,10 +25,15 @@ import {
   userMessage,
 } from "../providers/provider-send-message.js";
 import { parseFrontmatterFields } from "../skills/frontmatter.js";
+import type { InlineCommandExpansion } from "../skills/inline-command-expansions.js";
+import { parseInlineCommandExpansions } from "../skills/inline-command-expansions.js";
 import { parseToolManifestFile } from "../skills/tool-manifest.js";
 import { computeSkillVersionHash } from "../skills/version-hash.js";
 import { getLogger } from "../util/logger.js";
-import { getWorkspaceSkillsDir } from "../util/platform.js";
+import {
+  getWorkspaceDirDisplay,
+  getWorkspaceSkillsDir,
+} from "../util/platform.js";
 import { isAssistantFeatureFlagEnabled } from "./assistant-feature-flags.js";
 import { getConfig } from "./loader.js";
 
@@ -80,6 +85,8 @@ export interface SkillSummary {
   activationHints?: string[];
   /** Conditions under which this skill should NOT be loaded. */
   avoidWhen?: string[];
+  /** Parsed inline command expansion descriptors (`!\`command\``) found in the skill body. */
+  inlineCommandExpansions?: InlineCommandExpansion[];
 }
 
 export interface SkillDefinition extends SkillSummary {
@@ -198,6 +205,7 @@ interface ParsedFrontmatter {
   featureFlag?: string;
   activationHints?: string[];
   avoidWhen?: string[];
+  inlineCommandExpansions?: InlineCommandExpansion[];
 }
 
 function normalizeStringArray(raw: unknown): string[] | undefined {
@@ -302,16 +310,29 @@ function parseFrontmatter(
   const activationHints = normalizeStringArray(vellum?.["activation-hints"]);
   const avoidWhen = normalizeStringArray(vellum?.["avoid-when"]);
 
+  const strippedBody = stripCommentLines(body);
+
+  // Parse inline command expansions from the body (after frontmatter/comment stripping)
+  const expansionResult = parseInlineCommandExpansions(strippedBody);
+  const inlineCommandExpansions =
+    expansionResult.expansions.length > 0
+      ? expansionResult.expansions
+      : undefined;
+
+  // Fail closed: if there are malformed tokens, log and exclude from parsed expansions
+  // (errors are already logged inside parseInlineCommandExpansions)
+
   return {
     name,
     displayName,
     description,
-    body: stripCommentLines(body),
+    body: strippedBody,
     emoji,
     includes,
     featureFlag,
     activationHints,
     avoidWhen,
+    inlineCommandExpansions,
   };
 }
 
@@ -466,6 +487,7 @@ function readSkillFromDirectory(
       featureFlag: parsed.featureFlag,
       activationHints: parsed.activationHints,
       avoidWhen: parsed.avoidWhen,
+      inlineCommandExpansions: parsed.inlineCommandExpansions,
     };
   } catch (err) {
     log.warn({ err, skillFilePath }, "Failed to read skill file");
@@ -516,6 +538,7 @@ function readBundledSkillFromDirectory(
       featureFlag: parsed.featureFlag,
       activationHints: parsed.activationHints,
       avoidWhen: parsed.avoidWhen,
+      inlineCommandExpansions: parsed.inlineCommandExpansions,
     };
   } catch (err) {
     log.warn({ err, skillFilePath }, "Failed to read bundled skill file");
@@ -574,6 +597,7 @@ function loadBundledSkills(): SkillSummary[] {
       featureFlag: skill.featureFlag,
       activationHints: skill.activationHints,
       avoidWhen: skill.avoidWhen,
+      inlineCommandExpansions: skill.inlineCommandExpansions,
     });
   }
 
@@ -710,6 +734,7 @@ function skillSummaryFromDefinition(
     featureFlag: skill.featureFlag,
     activationHints: skill.activationHints,
     avoidWhen: skill.avoidWhen,
+    inlineCommandExpansions: skill.inlineCommandExpansions,
   };
 }
 
@@ -760,6 +785,7 @@ export function loadSkillCatalog(
             toolManifest: detectToolManifest(directory),
             includes: parsed.includes,
             featureFlag: parsed.featureFlag,
+            inlineCommandExpansions: parsed.inlineCommandExpansions,
           });
         } catch (err) {
           log.warn({ err, directory }, "Failed to read skill from extraDirs");
@@ -854,6 +880,7 @@ export function loadSkillCatalog(
           toolManifest: detectToolManifest(directory),
           includes: parsed.includes,
           featureFlag: parsed.featureFlag,
+          inlineCommandExpansions: parsed.inlineCommandExpansions,
         };
 
         if (seenIds.has(id)) {
@@ -1001,8 +1028,28 @@ function loadSkillDefinition(skill: SkillSummary): SkillLookupResult {
   }
   // Replace {baseDir} placeholders with the actual skill directory path
   loaded.body = loaded.body.replaceAll("{baseDir}", loaded.directoryPath);
+  // Replace {workspaceDir} placeholders with the runtime workspace display path
+  loaded.body = loaded.body.replaceAll(
+    "{workspaceDir}",
+    getWorkspaceDirDisplay(),
+  );
   // Strip feature-gated sections based on assistant feature flags
   loaded.body = applyFeatureGatedSections(loaded.body);
+
+  // Re-parse inline command expansions after placeholder substitution.
+  // The initial parse (during SKILL.md parsing) produces byte offsets against
+  // the pre-substitution body. Since {baseDir} and {workspaceDir} replacements
+  // change the body length, those offsets become stale. Re-parsing ensures the
+  // offsets match the final body that renderInlineCommands will operate on.
+  if (
+    loaded.inlineCommandExpansions &&
+    loaded.inlineCommandExpansions.length > 0
+  ) {
+    const reparse = parseInlineCommandExpansions(loaded.body);
+    loaded.inlineCommandExpansions =
+      reparse.expansions.length > 0 ? reparse.expansions : undefined;
+  }
+
   return { skill: loaded };
 }
 
@@ -1021,8 +1068,7 @@ export function resolveSkillSelector(
   const catalog = loadSkillCatalog(workspaceSkillsDir);
   if (catalog.length === 0) {
     return {
-      error:
-        "No skills are available. Configure ~/.vellum/workspace/skills/SKILLS.md or add skill directories.",
+      error: `No skills are available. Configure ${getWorkspaceDirDisplay()}/skills/SKILLS.md or add skill directories.`,
       errorCode: "empty_catalog",
     };
   }

package/src/contacts/contact-store.ts

@@ -295,21 +295,28 @@ function syncChannels(
       .get();
 
     if (existing) {
+      // Preserve guardian blocks: if the channel is blocked, do not overwrite
+      // its status/policy — mirrors the guard in the cross-contact reassignment
+      // path so a blocked channel cannot be unblocked via a same-contact sync.
+      const isBlocked = existing.status === "blocked";
+
       const updateSet: Record<string, unknown> = {};
       if (ch.isPrimary !== undefined) updateSet.isPrimary = ch.isPrimary;
       if (ch.externalUserId !== undefined)
         updateSet.externalUserId = ch.externalUserId;
       if (ch.externalChatId !== undefined)
         updateSet.externalChatId = ch.externalChatId;
-      if (ch.status !== undefined) updateSet.status = ch.status;
-      if (ch.policy !== undefined) updateSet.policy = ch.policy;
+      if (!isBlocked) {
+        if (ch.status !== undefined) updateSet.status = ch.status;
+        if (ch.policy !== undefined) updateSet.policy = ch.policy;
+        if (ch.revokedReason !== undefined)
+          updateSet.revokedReason = ch.revokedReason;
+        if (ch.blockedReason !== undefined)
+          updateSet.blockedReason = ch.blockedReason;
+      }
       if (ch.verifiedAt !== undefined) updateSet.verifiedAt = ch.verifiedAt;
       if (ch.verifiedVia !== undefined) updateSet.verifiedVia = ch.verifiedVia;
       if (ch.inviteId !== undefined) updateSet.inviteId = ch.inviteId;
-      if (ch.revokedReason !== undefined)
-        updateSet.revokedReason = ch.revokedReason;
-      if (ch.blockedReason !== undefined)
-        updateSet.blockedReason = ch.blockedReason;
 
       if (Object.keys(updateSet).length > 0) {
         updateSet.updatedAt = now;

package/src/contacts/contacts-write.ts

@@ -145,7 +145,6 @@ export function upsertContactChannel(params: {
   policy?: string;
   status?: string;
   inviteId?: string;
-  sourceConversationId?: string;
   verifiedAt?: number;
   verifiedVia?: string;
   role?: ContactRole;

package/src/context/window-manager.ts

@@ -681,13 +681,24 @@ function countPersistedMessages(messages: Message[]): number {
   }).length;
 }
 
-/** A user message that contains ONLY tool_result blocks (no text or other content). */
+function isSystemNoticeBlock(block: ContentBlock): boolean {
+  if (block.type !== "text") return false;
+  const text = (block as { text?: string }).text ?? "";
+  return (
+    text.startsWith("<system_notice>") && text.endsWith("</system_notice>")
+  );
+}
+
+/** A user message that contains ONLY tool_result blocks (no text or other content).
+ *  System notice text blocks (retry nudges, progress checks) do not count as user content. */
 function isToolResultOnly(message: Message): boolean {
   return (
     message.content.length > 0 &&
     message.content.every(
       (block) =>
-        block.type === "tool_result" || block.type === "web_search_tool_result",
+        block.type === "tool_result" ||
+        block.type === "web_search_tool_result" ||
+        isSystemNoticeBlock(block),
     )
   );
 }