@vellumai/assistant 0.5.2 → 0.5.4

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/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/daemon/conversation-agent-loop-handlers.ts

@@ -279,7 +279,12 @@ export function handleToolUse(
   state.toolCallTimestamps.set(event.id, { startedAt: Date.now() });
   state.currentToolUseId = event.id;
   state.currentTurnToolUseIds.push(event.id);
-  const statusText = `Running ${friendlyToolName(event.name)}`;
+  const statusText =
+    event.name === "skill_execute" &&
+    typeof event.input.activity === "string" &&
+    event.input.activity.length > 0
+      ? event.input.activity
+      : `Running ${friendlyToolName(event.name)}`;
   deps.ctx.emitActivityState(
     "tool_running",
     "tool_use_start",
@@ -398,8 +403,8 @@ export function handleInputJsonDelta(
   event: Extract<AgentEvent, { type: "input_json_delta" }>,
 ): void {
   // Only forward input deltas for app tools — the client only uses this
-  // stream for app_create/app_update code previews. Non-app tools would
-  // send large cumulative JSON on every delta with no benefit.
+  // stream for app_create code previews. Non-app tools would send large
+  // cumulative JSON on every delta with no benefit.
   if (!APP_TOOL_NAMES.has(event.toolName)) return;
   deps.onEvent({
     type: "tool_input_delta",

package/src/daemon/conversation-agent-loop.ts

@@ -33,6 +33,7 @@ import {
 } from "../instrument.js";
 import { commitAppTurnChanges } from "../memory/app-git-service.js";
 import { getApp, listAppFiles, resolveAppDir } from "../memory/app-store.js";
+import { insertCompactionEpisode } from "../memory/archive-store.js";
 import {
   addMessage,
   deleteMessageById,
@@ -208,7 +209,17 @@ export interface AgentLoopConversationContext {
   currentPage?: string;
   readonly surfaceState: Map<
     string,
-    { surfaceType: SurfaceType; data: SurfaceData; title?: string }
+    {
+      surfaceType: SurfaceType;
+      data: SurfaceData;
+      title?: string;
+      actions?: Array<{
+        id: string;
+        label: string;
+        style?: string;
+        data?: Record<string, unknown>;
+      }>;
+    }
   >;
   pendingSurfaceActions: Map<string, { surfaceType: SurfaceType }>;
   surfaceActionRequestIds: Set<string>;
@@ -503,6 +514,12 @@ export async function runAgentLoopImpl(
         compacted.summaryText,
         ctx.contextCompactedMessageCount,
       );
+      dualWriteCompactionEpisode(
+        ctx.conversationId,
+        ctx.memoryPolicy.scopeId,
+        compacted.summaryText,
+        compacted.summaryOutputTokens,
+      );
       onEvent({
         type: "context_compacted",
         previousEstimatedInputTokens: compacted.previousEstimatedInputTokens,
@@ -770,6 +787,12 @@ export async function runAgentLoopImpl(
             step.compactionResult.summaryText,
             ctx.contextCompactedMessageCount,
           );
+          dualWriteCompactionEpisode(
+            ctx.conversationId,
+            ctx.memoryPolicy.scopeId,
+            step.compactionResult.summaryText,
+            step.compactionResult.summaryOutputTokens,
+          );
           onEvent({
             type: "context_compacted",
             previousEstimatedInputTokens:
@@ -954,6 +977,12 @@ export async function runAgentLoopImpl(
           midLoopCompact.summaryText,
           ctx.contextCompactedMessageCount,
         );
+        dualWriteCompactionEpisode(
+          ctx.conversationId,
+          ctx.memoryPolicy.scopeId,
+          midLoopCompact.summaryText,
+          midLoopCompact.summaryOutputTokens,
+        );
         onEvent({
           type: "context_compacted",
           previousEstimatedInputTokens:
@@ -1150,6 +1179,12 @@ export async function runAgentLoopImpl(
             step.compactionResult.summaryText,
             ctx.contextCompactedMessageCount,
           );
+          dualWriteCompactionEpisode(
+            ctx.conversationId,
+            ctx.memoryPolicy.scopeId,
+            step.compactionResult.summaryText,
+            step.compactionResult.summaryOutputTokens,
+          );
           onEvent({
             type: "context_compacted",
             previousEstimatedInputTokens:
@@ -1257,6 +1292,12 @@ export async function runAgentLoopImpl(
                 emergencyCompact.summaryText,
                 ctx.contextCompactedMessageCount,
               );
+              dualWriteCompactionEpisode(
+                ctx.conversationId,
+                ctx.memoryPolicy.scopeId,
+                emergencyCompact.summaryText,
+                emergencyCompact.summaryOutputTokens,
+              );
               onEvent({
                 type: "context_compacted",
                 previousEstimatedInputTokens:
@@ -1361,6 +1402,12 @@ export async function runAgentLoopImpl(
               emergencyCompact.summaryText,
               ctx.contextCompactedMessageCount,
             );
+            dualWriteCompactionEpisode(
+              ctx.conversationId,
+              ctx.memoryPolicy.scopeId,
+              emergencyCompact.summaryText,
+              emergencyCompact.summaryOutputTokens,
+            );
             onEvent({
               type: "context_compacted",
               previousEstimatedInputTokens:
@@ -1826,3 +1873,26 @@ function collapseRawResponses(rawResponses?: unknown[]): unknown | undefined {
   if (!rawResponses || rawResponses.length === 0) return undefined;
   return rawResponses.length === 1 ? rawResponses[0] : rawResponses;
 }
+
+/**
+ * Dual-write a compaction summary as an archive episode so it becomes
+ * searchable via vector recall. Called after each successful compaction
+ * that produces a new summary.
+ */
+function dualWriteCompactionEpisode(
+  conversationId: string,
+  scopeId: string,
+  summaryText: string,
+  summaryOutputTokens: number,
+): void {
+  const now = Date.now();
+  insertCompactionEpisode({
+    conversationId,
+    scopeId,
+    title: truncate(summaryText, 120, ""),
+    summary: summaryText,
+    tokenEstimate: summaryOutputTokens,
+    startAt: now,
+    endAt: now,
+  });
+}

package/src/daemon/conversation-lifecycle.ts

@@ -123,7 +123,17 @@ export interface AbortContext {
   surfaceActionRequestIds: Set<string>;
   surfaceState: Map<
     string,
-    { surfaceType: SurfaceType; data: SurfaceData; title?: string }
+    {
+      surfaceType: SurfaceType;
+      data: SurfaceData;
+      title?: string;
+      actions?: Array<{
+        id: string;
+        label: string;
+        style?: string;
+        data?: Record<string, unknown>;
+      }>;
+    }
   >;
   accumulatedSurfaceState: Map<string, Record<string, unknown>>;
   readonly queue: MessageQueue;

package/src/daemon/conversation-memory.ts

@@ -1,5 +1,8 @@
 import { getConfig } from "../config/loader.js";
 import { estimatePromptTokens } from "../context/token-estimator.js";
+import { buildArchiveRecall } from "../memory/archive-recall.js";
+import { compileMemoryBrief } from "../memory/brief.js";
+import { getDb } from "../memory/db.js";
 import { buildMemoryQuery } from "../memory/query-builder.js";
 import { computeRecallBudget } from "../memory/retrieval-budget.js";
 import {
@@ -9,8 +12,11 @@ import {
 import type { ScopePolicyOverride } from "../memory/search/types.js";
 import type { Message } from "../providers/types.js";
 import type { Provider } from "../providers/types.js";
+import { getLogger } from "../util/logger.js";
 import type { ServerMessage } from "./message-protocol.js";
 
+const log = getLogger("conversation-memory");
+
 export interface MemoryRecallResult {
   runMessages: Message[];
   recall: Awaited<ReturnType<typeof buildMemoryRecall>>;
@@ -115,6 +121,14 @@ export async function prepareMemoryContext(
 
   const runtimeConfig = getConfig();
 
+  // ── Simplified memory path ──────────────────────────────────────────
+  // When `memory.simplified.enabled` is true, inject the brief and
+  // optional archive recall instead of the legacy hybrid pipeline.
+  if (runtimeConfig.memory?.simplified?.enabled) {
+    return prepareSimplifiedMemoryContext(ctx, content, userMessageId, onEvent);
+  }
+
+  // ── Legacy memory path (fallback) ──────────────────────────────────
   // Memory recall via the V2 hybrid pipeline
   const recallQuery = buildMemoryQuery(content, ctx.messages);
   const dynamicBudgetConfig = runtimeConfig.memory?.retrieval?.dynamicBudget;
@@ -207,3 +221,106 @@ export async function prepareMemoryContext(
     recall,
   };
 }
+
+// ── Simplified memory injection ─────────────────────────────────────────
+
+/**
+ * Build simplified memory context for a turn: compiles the `<memory_brief>`
+ * block and conditionally appends `<supporting_recall>` from the archive.
+ *
+ * Non-empty blocks are injected as text content blocks prepended to the
+ * last user message, following the same injection pattern as the legacy
+ * pipeline. Stripping is handled by `RUNTIME_INJECTION_PREFIXES` which
+ * already includes `<memory_brief>`.
+ */
+function prepareSimplifiedMemoryContext(
+  ctx: MemoryPrepareContext,
+  content: string,
+  userMessageId: string,
+  onEvent: (msg: ServerMessage) => void,
+): MemoryRecallResult {
+  const start = Date.now();
+
+  // Build a no-op recall result matching the legacy shape.
+  const noopRecall = (): Awaited<ReturnType<typeof buildMemoryRecall>> =>
+    ({
+      enabled: true,
+      degraded: false,
+      injectedText: "",
+      semanticHits: 0,
+      recencyHits: 0,
+      mergedCount: 0,
+      selectedCount: 0,
+      injectedTokens: 0,
+      latencyMs: 0,
+      topCandidates: [],
+      tier1Count: 0,
+      tier2Count: 0,
+    }) as Awaited<ReturnType<typeof buildMemoryRecall>>;
+
+  try {
+    const db = getDb();
+
+    // Step 1: Build the memory brief
+    const briefResult = compileMemoryBrief(db, ctx.scopeId, userMessageId);
+
+    // Step 2: Conditionally build supporting recall from the archive
+    const archiveResult = buildArchiveRecall(ctx.scopeId, content);
+
+    // Step 3: Assemble the injection blocks (non-empty only)
+    const blocks: string[] = [];
+    if (briefResult.text.length > 0) {
+      blocks.push(briefResult.text);
+    }
+    if (archiveResult.text.length > 0) {
+      blocks.push(archiveResult.text);
+    }
+
+    const latencyMs = Date.now() - start;
+
+    // Emit memory status for the simplified path
+    onEvent({
+      type: "memory_status",
+      enabled: true,
+      degraded: false,
+    });
+
+    // Inject non-empty blocks into the last user message
+    let runMessages = ctx.messages;
+    if (blocks.length > 0) {
+      const injectedText = blocks.join("\n\n");
+      const userTail = ctx.messages[ctx.messages.length - 1];
+      if (userTail && userTail.role === "user") {
+        runMessages = injectMemoryRecallAsUserBlock(ctx.messages, injectedText);
+      }
+
+      log.debug(
+        {
+          briefLength: briefResult.text.length,
+          recallTrigger: archiveResult.trigger,
+          recallBullets: archiveResult.bullets.length,
+          latencyMs,
+        },
+        "Simplified memory injection completed",
+      );
+    }
+
+    return {
+      runMessages,
+      recall: {
+        ...noopRecall(),
+        injectedText: blocks.length > 0 ? blocks.join("\n\n") : "",
+        latencyMs,
+      },
+    };
+  } catch (err) {
+    log.warn({ err }, "Simplified memory injection failed, returning no-op");
+    return {
+      runMessages: ctx.messages,
+      recall: {
+        ...noopRecall(),
+        latencyMs: Date.now() - start,
+      },
+    };
+  }
+}

package/src/daemon/conversation-runtime-assembly.ts

@@ -306,7 +306,7 @@ export function injectActiveSurfaceContext(
       'PREREQUISITE: If `app_refresh` is not yet available, call `skill_load` with `id: "app-builder"` first to load it.',
       "",
       "RULES FOR WORKSPACE MODIFICATION:",
-      `1. Use \`file_edit\` to make surgical changes to app files. The file path is \`~/.vellum/workspace/data/apps/${slug}/<path>\`.`,
+      `1. Use \`file_edit\` to make surgical changes to app files. The file path is \`${getAppDirPath(ctx.appId)}/<path>\`.`,
       "2. Use `file_write` to create new files or rewrite files.",
       "3. Use `file_read` to read any file with line numbers before editing.",
       "4. Use `bash ls` to see all files in the app directory.",
@@ -961,6 +961,8 @@ const RUNTIME_INJECTION_PREFIXES = [
   "<inbound_actor_context>",
   "<interface_turn_context>",
   "<turn_context>",
+  "<memory_brief>",
+  "<supporting_recall>",
   "<memory_context __injected>",
   "<memory_context>", // backward-compat: strip legacy blocks from pre-__injected history
   "<voice_call_control>",

package/src/daemon/conversation-surfaces.ts

@@ -172,6 +172,7 @@ export interface SurfaceConversationContext {
     emit(type: string, message: string, meta?: Record<string, unknown>): void;
   };
   sendToClient(msg: ServerMessage): void;
+  broadcastToAllClients?(msg: ServerMessage): void;
   pendingSurfaceActions: Map<string, { surfaceType: SurfaceType }>;
   lastSurfaceAction: Map<
     string,
@@ -617,10 +618,18 @@ export function handleSurfaceAction(
     const prompt =
       isRelay && typeof data?.prompt === "string" ? data.prompt.trim() : "";
 
+    // Read accumulated state once — used by both relay and custom action paths.
+    const accState = ctx.accumulatedSurfaceState.get(surfaceId);
+    const hasAccState = accState && Object.keys(accState).length > 0;
+
     let content: string;
     let displayContent: string | undefined;
     if (prompt) {
       content = prompt;
+      // Re-append accumulated state so the LLM sees it, matching the pending path.
+      if (hasAccState) {
+        content += `\n\nAccumulated surface state: ${JSON.stringify(accState)}`;
+      }
     } else {
       // Custom action from an app (e.g. sendAction('answer_selected', {...}))
       const summary = actionId
@@ -630,17 +639,20 @@ export function handleSurfaceAction(
       if (data && Object.keys(data).length > 0) {
         content += `\n\nAction data: ${JSON.stringify(data)}`;
       }
-      const accState = ctx.accumulatedSurfaceState.get(surfaceId);
-      if (accState && Object.keys(accState).length > 0) {
+      if (hasAccState) {
         content += `\n\nAccumulated surface state: ${JSON.stringify(accState)}`;
-        ctx.accumulatedSurfaceState.delete(surfaceId);
       }
       displayContent = summary;
     }
 
     const requestId = uuid();
     ctx.surfaceActionRequestIds.add(requestId);
-    const onEvent = (msg: ServerMessage) => ctx.sendToClient(msg);
+    // Use broadcastToAllClients (publishes to the SSE event hub) instead of
+    // sendToClient, which is reset to a no-op between HTTP requests. Without
+    // this, surface action responses are persisted to DB but never reach the
+    // client's SSE stream.
+    const emit = ctx.broadcastToAllClients ?? ctx.sendToClient.bind(ctx);
+    const onEvent = (msg: ServerMessage) => emit(msg);
 
     ctx.traceEmitter.emit("request_received", "Surface action received", {
       requestId,
@@ -665,10 +677,16 @@ export function handleSurfaceAction(
       return;
     }
 
+    // One-shot: clear accumulated state now that the message has been accepted.
+    // Deferred until after rejection check so state is preserved for retry on rejection.
+    if (hasAccState) {
+      ctx.accumulatedSurfaceState.delete(surfaceId);
+    }
+
     // Echo the prompt to the client so it appears in the chat UI.
     // Deferred until after rejection check to avoid ghost messages.
     if (prompt) {
-      ctx.sendToClient({
+      emit({
         type: "user_message_echo",
         text: prompt,
         conversationId: ctx.conversationId,
@@ -768,11 +786,16 @@ export function handleSurfaceAction(
     surfaceData,
   );
 
+  // Use broadcastToAllClients so events reach the SSE hub — sendToClient is
+  // reset to a no-op between HTTP requests (see history-restored path for
+  // full rationale).
+  const emit = ctx.broadcastToAllClients ?? ctx.sendToClient.bind(ctx);
+
   // Forms are one-shot surfaces — auto-complete immediately so the client
   // transitions from the "Submitting…" spinner to a completion chip without
   // requiring the LLM to call ui_dismiss.
   if (pending.surfaceType === "form") {
-    ctx.sendToClient({
+    emit({
       type: "ui_surface_complete",
       conversationId: ctx.conversationId,
       surfaceId,
@@ -833,7 +856,7 @@ export function handleSurfaceAction(
 
   const requestId = uuid();
   ctx.surfaceActionRequestIds.add(requestId);
-  const onEvent = (msg: ServerMessage) => ctx.sendToClient(msg);
+  const onEvent = (msg: ServerMessage) => emit(msg);
 
   ctx.traceEmitter.emit("request_received", "Surface action received", {
     requestId,
@@ -866,7 +889,7 @@ export function handleSurfaceAction(
   // Echo the user's prompt to the client so it appears in the chat UI.
   // Deferred until after rejection check to avoid ghost messages.
   if (shouldRelayPrompt && prompt) {
-    ctx.sendToClient({
+    emit({
       type: "user_message_echo",
       text: prompt,
       conversationId: ctx.conversationId,