@vellumai/assistant 0.5.13 → 0.5.15

package/src/daemon/conversation-notifiers.ts

@@ -22,6 +22,7 @@ import {
   addMessage,
   provenanceFromTrustContext,
 } from "../memory/conversation-crud.js";
+import { setMessageIdOnLogs } from "../memory/llm-request-log-store.js";
 import type { Message } from "../providers/types.js";
 import type { WatchSession } from "../tools/watch/watch-state.js";
 import {
@@ -69,37 +70,73 @@ export function registerConversationNotifiers(
     });
   });
 
-  registerWatchCommentaryNotifier(conversationId, (_session: WatchSession) => {
-    const commentary = lastCommentaryByConversation.get(conversationId);
-    if (commentary) {
-      lastCommentaryByConversation.delete(conversationId);
-      ctx.sendToClient({
-        type: "assistant_text_delta",
-        text: commentary,
-        conversationId: conversationId,
-      });
-      ctx.sendToClient({
-        type: "message_complete",
-        conversationId: conversationId,
-      });
-    }
-  });
+  registerWatchCommentaryNotifier(
+    conversationId,
+    async (_session: WatchSession) => {
+      const result = lastCommentaryByConversation.get(conversationId);
+      if (result) {
+        lastCommentaryByConversation.delete(conversationId);
 
-  registerWatchCompletionNotifier(conversationId, (_session: WatchSession) => {
-    const summary = lastSummaryByConversation.get(conversationId);
-    if (summary) {
-      lastSummaryByConversation.delete(conversationId);
-      ctx.sendToClient({
-        type: "assistant_text_delta",
-        text: summary,
-        conversationId: conversationId,
-      });
-      ctx.sendToClient({
-        type: "message_complete",
-        conversationId: conversationId,
-      });
-    }
-  });
+        const msg = await addMessage(
+          conversationId,
+          "assistant",
+          JSON.stringify([{ type: "text", text: result.text }]),
+          provenanceFromTrustContext(ctx.trustContext),
+        );
+        ctx.messages.push(createAssistantMessage(result.text));
+
+        try {
+          setMessageIdOnLogs(result.logIds, msg.id);
+        } catch {
+          // non-fatal — message is persisted even if log linkage fails
+        }
+
+        ctx.sendToClient({
+          type: "assistant_text_delta",
+          text: result.text,
+          conversationId: conversationId,
+        });
+        ctx.sendToClient({
+          type: "message_complete",
+          conversationId: conversationId,
+        });
+      }
+    },
+  );
+
+  registerWatchCompletionNotifier(
+    conversationId,
+    async (_session: WatchSession) => {
+      const result = lastSummaryByConversation.get(conversationId);
+      if (result) {
+        lastSummaryByConversation.delete(conversationId);
+
+        const msg = await addMessage(
+          conversationId,
+          "assistant",
+          JSON.stringify([{ type: "text", text: result.text }]),
+          provenanceFromTrustContext(ctx.trustContext),
+        );
+        ctx.messages.push(createAssistantMessage(result.text));
+
+        try {
+          setMessageIdOnLogs(result.logIds, msg.id);
+        } catch {
+          // non-fatal — message is persisted even if log linkage fails
+        }
+
+        ctx.sendToClient({
+          type: "assistant_text_delta",
+          text: result.text,
+          conversationId: conversationId,
+        });
+        ctx.sendToClient({
+          type: "message_complete",
+          conversationId: conversationId,
+        });
+      }
+    },
+  );
 
   registerCallQuestionNotifier(
     conversationId,

package/src/daemon/conversation-process.ts

@@ -17,6 +17,7 @@ import type {
 } from "../channels/types.js";
 import { parseChannelId, parseInterfaceId } from "../channels/types.js";
 import { getConfig } from "../config/loader.js";
+import type { ContextWindowResult } from "../context/window-manager.js";
 import { listPendingRequestsByConversationScope } from "../memory/canonical-guardian-store.js";
 import {
   addMessage,
@@ -47,6 +48,20 @@ import { resolveVerificationSessionIntent } from "./verification-session-intent.
 
 const log = getLogger("conversation-process");
 
+/** Format the result of a forced compaction into a user-facing message. */
+export function formatCompactResult(result: ContextWindowResult): string {
+  const fmt = (n: number) => n.toLocaleString("en-US");
+  if (!result.compacted) {
+    return `Context compaction skipped — ${result.reason ?? "nothing to compact"}.`;
+  }
+  const saved = result.previousEstimatedInputTokens - result.estimatedInputTokens;
+  return [
+    "Context Compacted\n",
+    `Tokens:   ${fmt(result.previousEstimatedInputTokens)} → ${fmt(result.estimatedInputTokens)} (${fmt(saved)} saved)`,
+    `Messages: ${fmt(result.compactedMessages)} compacted`,
+  ].join("\n");
+}
+
 /** Build a model_info event with fresh config data. */
 export async function buildModelInfoEvent(): Promise<ServerMessage> {
   return { type: "model_info", ...(await getModelInfo()) };
@@ -139,6 +154,8 @@ export interface ProcessConversationContext {
     requestId?: string,
     statusText?: string,
   ): void;
+  /** Force context compaction regardless of threshold/cooldown. */
+  forceCompact(): Promise<ContextWindowResult>;
 }
 
 function resolveQueuedTurnContext(
@@ -335,6 +352,7 @@ export async function drainQueue(
         ...(Object.keys(drainImageSourcePaths).length > 0
           ? { imageSourcePaths: drainImageSourcePaths }
           : {}),
+        sentAt: next.sentAt,
       };
       const cleanUserMsg = createUserMessage(next.content, next.attachments);
       const llmUserMsg = enrichMessageWithSourcePaths(
@@ -362,7 +380,7 @@ export async function drainQueue(
         conversation.conversationId,
         "assistant",
         JSON.stringify(assistantMsg.content),
-        drainChannelMeta,
+        { ...drainChannelMeta, sentAt: Date.now() },
       );
       conversation.messages.push(assistantMsg);
 
@@ -423,6 +441,82 @@ export async function drainQueue(
     return;
   }
 
+  // /compact — force context compaction, persist exchange, continue draining.
+  if (slashResult.kind === "compact") {
+    try {
+      const drainProvenance = provenanceFromTrustContext(
+        conversation.trustContext,
+      );
+      const drainChannelMeta = {
+        ...drainProvenance,
+        ...(queuedTurnCtx
+          ? {
+              userMessageChannel: queuedTurnCtx.userMessageChannel,
+              assistantMessageChannel: queuedTurnCtx.assistantMessageChannel,
+            }
+          : {}),
+        ...(queuedInterfaceCtx
+          ? {
+              userMessageInterface: queuedInterfaceCtx.userMessageInterface,
+              assistantMessageInterface:
+                queuedInterfaceCtx.assistantMessageInterface,
+            }
+          : {}),
+        sentAt: next.sentAt,
+      };
+      const cleanUserMsg = createUserMessage(next.content, next.attachments);
+      await addMessage(
+        conversation.conversationId,
+        "user",
+        JSON.stringify(cleanUserMsg.content),
+        drainChannelMeta,
+      );
+      conversation.messages.push(cleanUserMsg);
+
+      conversation.emitActivityState(
+        "thinking",
+        "context_compacting",
+        "assistant_turn",
+        next.requestId,
+      );
+      const result = await conversation.forceCompact();
+      const responseText = formatCompactResult(result);
+
+      const assistantMsg = createAssistantMessage(responseText);
+      await addMessage(
+        conversation.conversationId,
+        "assistant",
+        JSON.stringify(assistantMsg.content),
+        { ...drainChannelMeta, sentAt: Date.now() },
+      );
+      conversation.messages.push(assistantMsg);
+
+      next.onEvent({ type: "assistant_text_delta", text: responseText });
+      conversation.traceEmitter.emit(
+        "message_complete",
+        "Compact slash command handled",
+        { requestId: next.requestId, status: "success" },
+      );
+      next.onEvent({
+        type: "message_complete",
+        conversationId: conversation.conversationId,
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      log.error(
+        {
+          err,
+          conversationId: conversation.conversationId,
+          requestId: next.requestId,
+        },
+        "Failed to execute /compact",
+      );
+      next.onEvent({ type: "error", message });
+    }
+    await drainQueue(conversation);
+    return;
+  }
+
   const resolvedContent = slashResult.content;
 
   // Guardian verification intent interception for queued messages.
@@ -455,7 +549,7 @@ export async function drainQueue(
       resolvedContent,
       next.attachments,
       next.requestId,
-      next.metadata,
+      { ...next.metadata, sentAt: next.sentAt },
       next.displayContent,
     );
   } catch (err) {
@@ -780,6 +874,71 @@ export async function processMessage(
     return persisted.id;
   }
 
+  // /compact — force context compaction, persist exchange, return message ID.
+  if (slashResult.kind === "compact") {
+    conversation.processing = true;
+    try {
+      const pmTurnCtx = conversation.getTurnChannelContext();
+      const pmInterfaceCtx = conversation.getTurnInterfaceContext();
+      const pmProvenance = provenanceFromTrustContext(conversation.trustContext);
+      const pmChannelMeta = {
+        ...pmProvenance,
+        ...(pmTurnCtx
+          ? {
+              userMessageChannel: pmTurnCtx.userMessageChannel,
+              assistantMessageChannel: pmTurnCtx.assistantMessageChannel,
+            }
+          : {}),
+        ...(pmInterfaceCtx
+          ? {
+              userMessageInterface: pmInterfaceCtx.userMessageInterface,
+              assistantMessageInterface: pmInterfaceCtx.assistantMessageInterface,
+            }
+          : {}),
+      };
+      const cleanUserMsg = createUserMessage(content, attachments);
+      const persisted = await addMessage(
+        conversation.conversationId,
+        "user",
+        JSON.stringify(cleanUserMsg.content),
+        pmChannelMeta,
+      );
+      conversation.messages.push(cleanUserMsg);
+
+      conversation.emitActivityState(
+        "thinking",
+        "context_compacting",
+        "assistant_turn",
+        requestId,
+      );
+      const result = await conversation.forceCompact();
+      const responseText = formatCompactResult(result);
+
+      const assistantMsg = createAssistantMessage(responseText);
+      await addMessage(
+        conversation.conversationId,
+        "assistant",
+        JSON.stringify(assistantMsg.content),
+        pmChannelMeta,
+      );
+      conversation.messages.push(assistantMsg);
+
+      onEvent({ type: "assistant_text_delta", text: responseText });
+      conversation.traceEmitter.emit(
+        "message_complete",
+        "Compact slash command handled",
+        { requestId, status: "success" },
+      );
+      onEvent({
+        type: "message_complete",
+        conversationId: conversation.conversationId,
+      });
+      return persisted.id;
+    } finally {
+      conversation.processing = false;
+    }
+  }
+
   const resolvedContent = slashResult.content;
 
   // Guardian verification intent interception — force direct guardian

package/src/daemon/conversation-queue-manager.ts

@@ -31,6 +31,8 @@ export interface QueuedMessage {
   isInteractive?: boolean;
   /** Original user message text to persist to DB when recording intent stripping produced a different `content`. */
   displayContent?: string;
+  /** Wall-clock time (ms since epoch) when the message was enqueued, used as the display timestamp. */
+  sentAt: number;
 }
 
 /**

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

@@ -16,11 +16,11 @@ import {
   type TurnInterfaceContext,
 } from "../channels/types.js";
 import { getAppDirPath, listAppFiles } from "../memory/app-store.js";
-import { stripCommentLines } from "../prompts/system-prompt.js";
 import type { Message } from "../providers/types.js";
 import type { ActorTrustContext } from "../runtime/actor-trust-resolver.js";
 import { channelStatusToMemberStatus } from "../runtime/routes/inbound-stages/acl-enforcement.js";
 import { getWorkspacePromptPath } from "../util/platform.js";
+import { stripCommentLines } from "../util/strip-comment-lines.js";
 
 /**
  * Describes the capabilities of the channel through which the user is
@@ -487,28 +487,49 @@ export function readNowScratchpad(): string | null {
 }
 
 /**
- * Append NOW.md scratchpad content to the last user message so the model
- * has access to the user's ephemeral scratchpad notes at the end of context.
+ * Insert NOW.md scratchpad content into the user message, after any
+ * injected context blocks (e.g. memory_context) but before the user's
+ * original content.  This keeps the user's actual message as the last
+ * thing the model reads.
  */
 export function injectNowScratchpad(
   message: Message,
   content: string,
 ): Message {
+  const scratchpadBlock = {
+    type: "text" as const,
+    text: `<NOW.md Always keep this up to date>\n${content}\n</NOW.md>`,
+  };
+
+  // Find insertion point: skip any leading injected-context text blocks
+  // (e.g. memory_context) so the scratchpad lands between injected context
+  // and the user's original content.
+  let insertIdx = 0;
+  for (let i = 0; i < message.content.length; i++) {
+    const block = message.content[i];
+    if (block.type === "text" && block.text.startsWith("<memory_context")) {
+      insertIdx = i + 1;
+    } else {
+      break;
+    }
+  }
+
   return {
     ...message,
     content: [
-      ...message.content,
-      {
-        type: "text",
-        text: `<now_scratchpad>\n${content}\n</now_scratchpad>`,
-      },
+      ...message.content.slice(0, insertIdx),
+      scratchpadBlock,
+      ...message.content.slice(insertIdx),
     ],
   };
 }
 
-/** Strip `<now_scratchpad>` blocks injected by `injectNowScratchpad`. */
+/** Strip `<NOW.md>` blocks injected by `injectNowScratchpad`. */
 export function stripNowScratchpad(messages: Message[]): Message[] {
-  return stripUserTextBlocksByPrefix(messages, ["<now_scratchpad>"]);
+  return stripUserTextBlocksByPrefix(messages, [
+    "<NOW.md Always keep this up to date>",
+    "<now_scratchpad>", // backward-compat: strip legacy blocks from pre-rename history
+  ]);
 }
 
 /**
@@ -1034,7 +1055,8 @@ const RUNTIME_INJECTION_PREFIXES = [
   "<active_workspace>",
   "<active_dynamic_page>",
   "<non_interactive_context>",
-  "<now_scratchpad>",
+  "<NOW.md Always keep this up to date>",
+  "<now_scratchpad>", // backward-compat: strip legacy blocks from pre-rename history
   "<transport_hints>",
 ];
 

package/src/daemon/conversation-slash.ts

@@ -16,7 +16,8 @@ import type { PairingStore } from "./pairing-store.js";
 
 export type SlashResolution =
   | { kind: "passthrough"; content: string }
-  | { kind: "unknown"; message: string; qrFilename?: string };
+  | { kind: "unknown"; message: string; qrFilename?: string }
+  | { kind: "compact" };
 
 // ── /pair command — module-level pairing context ────────────────────
 
@@ -129,6 +130,7 @@ function resolveStatusCommand(context: SlashContext): SlashResolution {
 function resolveCommandsList(context?: SlashContext): string[] {
   const fallbackLines = [
     "/commands — List all available commands",
+    "/compact — Force context compaction immediately",
     "/models — List all available models",
     "/pair — Generate pairing info for connecting a mobile device",
   ];
@@ -141,6 +143,7 @@ function resolveCommandsList(context?: SlashContext): string[] {
   if (context.userMessageInterface === "macos") {
     return [
       "/commands — List all available commands",
+      "/compact — Force context compaction immediately",
       "/models — List all available models",
       "/status — Show conversation status and context usage",
       "/btw — Ask a side question while the assistant is working",
@@ -152,6 +155,7 @@ function resolveCommandsList(context?: SlashContext): string[] {
   if (context.userMessageInterface === "ios") {
     return [
       "/commands — List all available commands",
+      "/compact — Force context compaction immediately",
       "/models — List all available models",
       "/status — Show conversation status and context usage",
       "/btw — Ask a side question while the assistant is working",
@@ -161,6 +165,7 @@ function resolveCommandsList(context?: SlashContext): string[] {
 
   return [
     "/commands — List all available commands",
+    "/compact — Force context compaction immediately",
     "/models — List all available models",
     "/status — Show conversation status and context usage",
     "/btw — Ask a side question while the assistant is working",
@@ -168,8 +173,9 @@ function resolveCommandsList(context?: SlashContext): string[] {
 }
 
 /**
- * Resolve built-in slash commands (/models, /status, /commands, /pair).
- * Returns `unknown` with a deterministic message, or the (possibly rewritten) content.
+ * Resolve built-in slash commands (/models, /status, /commands, /compact, /pair).
+ * Returns `unknown` with a deterministic message, `compact` for forced compaction,
+ * or the (possibly rewritten) content as `passthrough`.
  */
 export async function resolveSlash(
   content: string,
@@ -209,6 +215,11 @@ export async function resolveSlash(
   const pairResult = resolvePairCommand(content, context);
   if (pairResult) return pairResult;
 
+  // Handle /compact command
+  if (trimmed === "/compact") {
+    return { kind: "compact" };
+  }
+
   // Handle /status command
   if (trimmed === "/status") {
     if (!context) {

package/src/daemon/conversation-tool-setup.ts

@@ -177,6 +177,8 @@ export function createToolExecutor(
         ctx.surfaceActionRequestIds?.has(ctx.currentRequestId ?? "") ?? false,
       requesterExternalUserId: ctx.trustContext?.requesterExternalUserId,
       requesterChatId: ctx.trustContext?.requesterChatId,
+      requesterIdentifier: ctx.trustContext?.requesterIdentifier,
+      requesterDisplayName: ctx.trustContext?.requesterDisplayName,
       channelPermissionChannelId:
         ctx.trustContext?.sourceChannel === "slack"
           ? getBindingByConversation(ctx.conversationId)?.externalChatId

package/src/daemon/conversation-usage.ts

@@ -75,6 +75,26 @@ function extractAnthropicCacheCreation(
   };
 }
 
+/**
+ * Extract the speed indicator from Anthropic fast mode API responses.
+ * The API returns `usage.speed: "fast" | "standard"` when using the
+ * fast-mode beta. For multi-response arrays, returns "fast" if any
+ * response used fast mode.
+ */
+function extractAnthropicSpeed(
+  rawResponse: unknown,
+): "fast" | "standard" | null {
+  const responses = Array.isArray(rawResponse) ? rawResponse : [rawResponse];
+  let foundStandard = false;
+  for (const response of responses) {
+    const rec = asRecord(response);
+    const usage = asRecord(rec?.usage);
+    if (usage?.speed === "fast") return "fast";
+    if (usage?.speed === "standard") foundStandard = true;
+  }
+  return foundStandard ? "standard" : null;
+}
+
 function resolveStructuredPricing(
   providerName: string,
   model: string,
@@ -105,6 +125,8 @@ export function recordUsage(
   cacheCreationInputTokens = 0,
   cacheReadInputTokens = 0,
   rawResponse?: unknown,
+  llmCallCount = 1,
+  contextWindow?: { tokens: number; maxTokens: number },
 ): void {
   if (inputTokens <= 0 && outputTokens <= 0) return;
 
@@ -120,15 +142,16 @@ export function recordUsage(
     0,
   );
 
+  const isAnthropic = ctx.providerName === "anthropic";
   const pricingUsage: PricingUsage = {
     directInputTokens,
     outputTokens,
     cacheCreationInputTokens: normalizedCacheCreationInputTokens,
     cacheReadInputTokens: normalizedCacheReadInputTokens,
-    anthropicCacheCreation:
-      ctx.providerName === "anthropic"
-        ? extractAnthropicCacheCreation(rawResponse)
-        : null,
+    anthropicCacheCreation: isAnthropic
+      ? extractAnthropicCacheCreation(rawResponse)
+      : null,
+    speed: isAnthropic ? extractAnthropicSpeed(rawResponse) : null,
   };
   const pricing = resolveStructuredPricing(
     ctx.providerName,
@@ -158,6 +181,10 @@ export function recordUsage(
     totalOutputTokens: ctx.usageStats.outputTokens,
     estimatedCost,
     model,
+    ...(contextWindow && {
+      contextWindowTokens: contextWindow.tokens,
+      contextWindowMaxTokens: contextWindow.maxTokens,
+    }),
   });
 
   // Dual-write: persist per-turn usage event to the new ledger table
@@ -174,6 +201,7 @@ export function recordUsage(
         conversationId: ctx.conversationId,
         runId: null,
         requestId,
+        llmCallCount,
       },
       pricing,
     );

package/src/daemon/conversation.ts

@@ -21,8 +21,13 @@ import type {
   TurnChannelContext,
   TurnInterfaceContext,
 } from "../channels/types.js";
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import { getConfig } from "../config/loader.js";
-import { ContextWindowManager } from "../context/window-manager.js";
+import type { Speed } from "../config/schemas/inference.js";
+import {
+  ContextWindowManager,
+  type ContextWindowResult,
+} from "../context/window-manager.js";
 import type { CesClient } from "../credential-execution/client.js";
 import { EventBus } from "../events/bus.js";
 import type { AssistantDomainEvents } from "../events/domain-events.js";
@@ -38,6 +43,7 @@ import {
 import { registerToolTraceListener } from "../events/tool-trace-listener.js";
 import { getHookManager } from "../hooks/manager.js";
 import { resolveCanonicalGuardianRequest } from "../memory/canonical-guardian-store.js";
+import { updateConversationContextWindow } from "../memory/conversation-crud.js";
 import { PermissionPrompter } from "../permissions/prompter.js";
 import { SecretPrompter } from "../permissions/secret-prompter.js";
 import { patternMatchesCandidate } from "../permissions/trust-store.js";
@@ -263,6 +269,7 @@ export class Conversation {
     broadcastToAllClients?: (msg: ServerMessage) => void,
     memoryPolicy?: ConversationMemoryPolicy,
     sharedCesClient?: CesClient,
+    speedOverride?: Speed,
   ) {
     this.conversationId = conversationId;
     this.systemPrompt = systemPrompt;
@@ -383,6 +390,9 @@ export class Conversation {
       return resolved;
     };
 
+    const fastModeEnabled = isAssistantFeatureFlagEnabled("fast-mode", config);
+    const resolvedSpeed = speedOverride ?? config.speed;
+
     this.agentLoop = new AgentLoop(
       provider,
       systemPrompt,
@@ -391,6 +401,9 @@ export class Conversation {
         maxInputTokens: config.contextWindow.maxInputTokens,
         thinking: config.thinking,
         effort: config.effort,
+        ...(fastModeEnabled && resolvedSpeed === "fast"
+          ? { speed: resolvedSpeed }
+          : {}),
       },
       toolDefs.length > 0 ? toolDefs : undefined,
       toolDefs.length > 0 ? toolExecutor : undefined,
@@ -873,6 +886,25 @@ export class Conversation {
     this.sendToClient(msg);
   }
 
+  async forceCompact(): Promise<ContextWindowResult> {
+    const result = await this.contextWindowManager.maybeCompact(
+      this.messages,
+      this.abortController?.signal ?? undefined,
+      { force: true, lastCompactedAt: this.contextCompactedAt ?? undefined },
+    );
+    if (result.compacted) {
+      this.messages = result.messages;
+      this.contextCompactedMessageCount += result.compactedPersistedMessages;
+      this.contextCompactedAt = Date.now();
+      updateConversationContextWindow(
+        this.conversationId,
+        result.summaryText,
+        this.contextCompactedMessageCount,
+      );
+    }
+    return result;
+  }
+
   setChannelCapabilities(caps: ChannelCapabilities | null): void {
     this.channelCapabilities = caps ?? undefined;
   }