@vellumai/assistant 0.5.13 → 0.5.15

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -589,7 +589,7 @@ describe("injectTemporalContext", () => {
   };
 
   const sampleContext =
-    "<temporal_context>\nToday: 2026-02-18 (Wednesday)\nTimezone: UTC\n</temporal_context>";
+    "<temporal_context>\nToday: 2026-02-18 (Wed) 12:00 +00:00\nTZ: UTC\n</temporal_context>";
 
   test("prepends temporal context block to user message", () => {
     const result = injectTemporalContext(baseUserMessage, sampleContext);
@@ -729,7 +729,7 @@ describe("applyRuntimeInjections with temporalContext", () => {
   ];
 
   const sampleContext =
-    "<temporal_context>\nToday: 2026-02-18 (Wednesday)\n</temporal_context>";
+    "<temporal_context>\nToday: 2026-02-18 (Wed) 12:00 +00:00\nTZ: UTC\n</temporal_context>";
 
   test("injects temporal context when provided", () => {
     const result = applyRuntimeInjections(baseMessages, {
@@ -1293,7 +1293,7 @@ describe("applyRuntimeInjections — injection mode", () => {
     workspaceTopLevelContext:
       "<workspace_top_level>\nRoot: /sandbox\n</workspace_top_level>",
     temporalContext:
-      "<temporal_context>\nToday: 2026-03-04 (Tuesday)\n</temporal_context>",
+      "<temporal_context>\nToday: 2026-03-04 (Tue) 12:00 +00:00\nTZ: UTC\n</temporal_context>",
     channelCommandContext: { type: "start" } as const,
     activeSurface: { surfaceId: "sf_1", html: "<div>test</div>" },
     channelCapabilities: {
@@ -1341,7 +1341,7 @@ describe("applyRuntimeInjections — injection mode", () => {
     expect(allText).toContain("<turn_context>");
     expect(allText).toContain("<inbound_actor_context>");
     expect(allText).toContain("<non_interactive_context>");
-    expect(allText).toContain("<now_scratchpad>");
+    expect(allText).toContain("<NOW.md");
   });
 
   test("explicit mode: 'full' behaves the same as default", () => {
@@ -1358,7 +1358,7 @@ describe("applyRuntimeInjections — injection mode", () => {
     expect(allText).toContain("<temporal_context>");
     expect(allText).toContain("<channel_command_context>");
     expect(allText).toContain("<active_workspace>");
-    expect(allText).toContain("<now_scratchpad>");
+    expect(allText).toContain("<NOW.md");
   });
 
   test("minimal mode skips high-token optional blocks", () => {
@@ -1376,7 +1376,7 @@ describe("applyRuntimeInjections — injection mode", () => {
     expect(allText).not.toContain("<temporal_context>");
     expect(allText).not.toContain("<channel_command_context>");
     expect(allText).not.toContain("<active_workspace>");
-    expect(allText).not.toContain("<now_scratchpad>");
+    expect(allText).not.toContain("<NOW.md");
   });
 
   test("minimal mode preserves safety-critical blocks", () => {
@@ -1435,26 +1435,51 @@ describe("injectNowScratchpad", () => {
     content: [{ type: "text", text: "What should I work on?" }],
   };
 
-  test("appends now_scratchpad block to user message", () => {
+  test("inserts NOW.md before user content", () => {
     const result = injectNowScratchpad(
       baseUserMessage,
       "Current focus: shipping PR 3",
     );
     expect(result.content.length).toBe(2);
-    // Original content comes first
-    expect((result.content[0] as { type: "text"; text: string }).text).toBe(
-      "What should I work on?",
-    );
-    // Scratchpad is appended (not prepended)
-    const injected = result.content[1];
+    // Scratchpad comes first (before user content)
+    const injected = result.content[0];
     expect(injected.type).toBe("text");
     const text = (injected as { type: "text"; text: string }).text;
     expect(text).toBe(
-      "<now_scratchpad>\nCurrent focus: shipping PR 3\n</now_scratchpad>",
+      "<NOW.md Always keep this up to date>\nCurrent focus: shipping PR 3\n</NOW.md>",
+    );
+    // Original content comes last
+    expect((result.content[1] as { type: "text"; text: string }).text).toBe(
+      "What should I work on?",
     );
   });
 
-  test("preserves existing multi-block content and appends at end", () => {
+  test("inserts after memory_context but before user content", () => {
+    const messageWithMemory: Message = {
+      role: "user",
+      content: [
+        { type: "text", text: "<memory_context __injected>\nrecalled notes\n</memory_context>" },
+        { type: "text", text: "What should I work on?" },
+      ],
+    };
+
+    const result = injectNowScratchpad(messageWithMemory, "scratchpad notes");
+    expect(result.content.length).toBe(3);
+    // Memory context stays first
+    expect(
+      (result.content[0] as { type: "text"; text: string }).text,
+    ).toContain("<memory_context");
+    // Scratchpad inserted after memory
+    expect(
+      (result.content[1] as { type: "text"; text: string }).text,
+    ).toContain("<NOW.md");
+    // User content is last
+    expect((result.content[2] as { type: "text"; text: string }).text).toBe(
+      "What should I work on?",
+    );
+  });
+
+  test("preserves existing multi-block content with scratchpad before it", () => {
     const multiBlockMessage: Message = {
       role: "user",
       content: [
@@ -1465,15 +1490,16 @@ describe("injectNowScratchpad", () => {
 
     const result = injectNowScratchpad(multiBlockMessage, "scratchpad notes");
     expect(result.content.length).toBe(3);
-    expect((result.content[0] as { type: "text"; text: string }).text).toBe(
+    // Scratchpad is first (no memory_context to skip)
+    expect(
+      (result.content[0] as { type: "text"; text: string }).text,
+    ).toContain("<NOW.md");
+    expect((result.content[1] as { type: "text"; text: string }).text).toBe(
       "First block",
     );
-    expect((result.content[1] as { type: "text"; text: string }).text).toBe(
+    expect((result.content[2] as { type: "text"; text: string }).text).toBe(
       "Second block",
     );
-    expect(
-      (result.content[2] as { type: "text"; text: string }).text,
-    ).toContain("<now_scratchpad>");
   });
 });
 
@@ -1482,7 +1508,7 @@ describe("injectNowScratchpad", () => {
 // ---------------------------------------------------------------------------
 
 describe("stripNowScratchpad", () => {
-  test("strips now_scratchpad blocks from user messages", () => {
+  test("strips NOW.md blocks from user messages", () => {
     const messages: Message[] = [
       {
         role: "user",
@@ -1490,7 +1516,7 @@ describe("stripNowScratchpad", () => {
           { type: "text", text: "Hello" },
           {
             type: "text",
-            text: "<now_scratchpad>\nSome notes\n</now_scratchpad>",
+            text: "<NOW.md Always keep this up to date>\nSome notes\n</NOW.md>",
           },
         ],
       },
@@ -1511,14 +1537,14 @@ describe("stripNowScratchpad", () => {
     expect(result[1].content.length).toBe(1);
   });
 
-  test("removes user messages that only contain now_scratchpad", () => {
+  test("removes user messages that only contain NOW.md", () => {
     const messages: Message[] = [
       {
         role: "user",
         content: [
           {
             type: "text",
-            text: "<now_scratchpad>\nSome notes\n</now_scratchpad>",
+            text: "<NOW.md Always keep this up to date>\nSome notes\n</NOW.md>",
           },
         ],
       },
@@ -1528,7 +1554,7 @@ describe("stripNowScratchpad", () => {
     expect(result.length).toBe(0);
   });
 
-  test("leaves messages without now_scratchpad untouched", () => {
+  test("leaves messages without NOW.md untouched", () => {
     const messages: Message[] = [
       {
         role: "user",
@@ -1543,11 +1569,11 @@ describe("stripNowScratchpad", () => {
 });
 
 // ---------------------------------------------------------------------------
-// stripInjectedContext removes now_scratchpad blocks
+// stripInjectedContext removes NOW.md blocks
 // ---------------------------------------------------------------------------
 
-describe("stripInjectedContext with now_scratchpad", () => {
-  test("strips now_scratchpad blocks alongside other injections", () => {
+describe("stripInjectedContext with NOW.md", () => {
+  test("strips NOW.md blocks alongside other injections", () => {
     const messages: Message[] = [
       {
         role: "user",
@@ -1559,7 +1585,7 @@ describe("stripInjectedContext with now_scratchpad", () => {
           { type: "text", text: "Hello" },
           {
             type: "text",
-            text: "<now_scratchpad>\nCurrent focus\n</now_scratchpad>",
+            text: "<NOW.md Always keep this up to date>\nCurrent focus\n</NOW.md>",
           },
         ],
       },
@@ -1586,32 +1612,32 @@ describe("applyRuntimeInjections with nowScratchpad", () => {
     },
   ];
 
-  test("injects now_scratchpad block when provided", () => {
+  test("injects NOW.md block when provided", () => {
     const result = applyRuntimeInjections(baseMessages, {
       nowScratchpad: "Current focus: fix the bug",
     });
 
     expect(result.length).toBe(1);
     expect(result[0].content.length).toBe(2);
-    const injected = result[0].content[1];
+    const injected = result[0].content[0];
     const text = (injected as { type: "text"; text: string }).text;
-    expect(text).toContain("<now_scratchpad>");
+    expect(text).toContain("<NOW.md");
     expect(text).toContain("Current focus: fix the bug");
   });
 
-  test("appended block appears after user's original text content", () => {
+  test("scratchpad appears before user's original text content", () => {
     const result = applyRuntimeInjections(baseMessages, {
       nowScratchpad: "scratchpad notes",
     });
 
-    // Original text is first
+    // Scratchpad comes first (before user content)
     expect(
       (result[0].content[0] as { type: "text"; text: string }).text,
-    ).toBe("What should I do?");
-    // Scratchpad is appended after
+    ).toContain("<NOW.md");
+    // Original text is last
     expect(
       (result[0].content[1] as { type: "text"; text: string }).text,
-    ).toContain("<now_scratchpad>");
+    ).toBe("What should I do?");
   });
 
   test("does not inject when nowScratchpad is null", () => {
@@ -1641,6 +1667,6 @@ describe("applyRuntimeInjections with nowScratchpad", () => {
       .map((b) => b.text)
       .join("\n");
 
-    expect(allText).not.toContain("<now_scratchpad>");
+    expect(allText).not.toContain("<NOW.md");
   });
 });

package/src/__tests__/conversation-slash-commands.test.ts

@@ -36,6 +36,7 @@ describe("resolveSlash /commands interface-aware help", () => {
     );
     expect(lines).toEqual([
       "/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",
@@ -53,6 +54,7 @@ describe("resolveSlash /commands interface-aware help", () => {
     );
     expect(lines).toEqual([
       "/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",
@@ -66,6 +68,7 @@ describe("resolveSlash /commands interface-aware help", () => {
     );
     expect(lines).toEqual([
       "/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",
@@ -76,6 +79,7 @@ describe("resolveSlash /commands interface-aware help", () => {
     const lines = await resolveCommandsLines(makeSlashContext());
     expect(lines).toEqual([
       "/commands — List all available commands",
+      "/compact — Force context compaction immediately",
       "/models — List all available models",
       "/pair — Generate pairing info for connecting a mobile device",
       "/status — Show conversation status and context usage",
@@ -86,6 +90,7 @@ describe("resolveSlash /commands interface-aware help", () => {
     const lines = await resolveCommandsLines();
     expect(lines).toEqual([
       "/commands — List all available commands",
+      "/compact — Force context compaction immediately",
       "/models — List all available models",
       "/pair — Generate pairing info for connecting a mobile device",
     ]);

package/src/__tests__/conversation-slash-queue.test.ts

@@ -17,10 +17,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
 }));
 
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => "/tmp",
-}));
-
 mock.module("../memory/guardian-action-store.js", () => ({
   getGuardianActionRequest: () => null,
   resolveGuardianActionRequest: () => {},

package/src/__tests__/conversation-slash-unknown.test.ts

@@ -17,10 +17,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
 }));
 
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => "/tmp",
-}));
-
 mock.module("../memory/guardian-action-store.js", () => ({
   getGuardianActionRequest: () => null,
   resolveGuardianActionRequest: () => {},

package/src/__tests__/conversation-speed-override.test.ts

@@ -0,0 +1,326 @@
+/**
+ * Tests for per-conversation speed override.
+ *
+ * Verifies that the Conversation constructor resolves speed from the
+ * per-conversation speedOverride parameter first, falling back to the
+ * global config speed setting.
+ */
+import { describe, expect, mock, test } from "bun:test";
+
+import type {
+  AgentEvent,
+  AgentLoopConfig,
+  CheckpointDecision,
+  CheckpointInfo,
+} from "../agent/loop.js";
+import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { Message, ProviderResponse } from "../providers/types.js";
+
+// ---------------------------------------------------------------------------
+// Mocks — must precede Conversation import
+// ---------------------------------------------------------------------------
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of [
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal",
+    "silent",
+    "child",
+  ]) {
+    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+mock.module("../memory/guardian-action-store.js", () => ({
+  getGuardianActionRequest: () => null,
+  resolveGuardianActionRequest: () => {},
+}));
+
+mock.module("../providers/registry.js", () => ({
+  getProvider: () => ({ name: "mock-provider" }),
+  initializeProviders: () => {},
+}));
+
+// Controllable config mock — speed and feature flag behavior are test-specific.
+let mockConfigSpeed: "standard" | "fast" = "fast";
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    provider: "mock-provider",
+    maxTokens: 4096,
+    thinking: false,
+    speed: mockConfigSpeed,
+    effort: "high",
+    contextWindow: {
+      maxInputTokens: 100000,
+      thresholdTokens: 80000,
+      preserveRecentMessages: 6,
+      summaryModel: "mock-model",
+      maxSummaryTokens: 512,
+    },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    timeouts: { permissionTimeoutSec: 1 },
+    skills: { entries: {}, allowBundled: true },
+    permissions: { mode: "workspace" },
+  }),
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
+}));
+
+// Feature flag mock — fast-mode enabled for all tests in this file.
+mock.module("../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: (key: string) => {
+    if (key === "fast-mode") return true;
+    return true;
+  },
+}));
+
+mock.module("../prompts/system-prompt.js", () => ({
+  buildSystemPrompt: () => "system prompt",
+}));
+
+mock.module("../config/skills.js", () => ({
+  loadSkillCatalog: () => [],
+  loadSkillBySelector: () => ({ skill: null }),
+  ensureSkillIcon: async () => null,
+}));
+
+mock.module("../config/skill-state.js", () => ({
+  resolveSkillStates: () => [],
+}));
+
+mock.module("../permissions/trust-store.js", () => ({
+  addRule: () => {},
+  findHighestPriorityRule: () => null,
+  clearCache: () => {},
+}));
+
+mock.module("../security/secret-allowlist.js", () => ({
+  resetAllowlist: () => {},
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  getConversationType: () => "default",
+  setConversationOriginChannelIfUnset: () => {},
+  updateConversationContextWindow: () => {},
+  deleteMessageById: () => {},
+  provenanceFromTrustContext: () => ({
+    source: "user",
+    trustContext: undefined,
+  }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
+  getMessages: () => [],
+  getConversation: () => ({
+    id: "conv-1",
+    contextSummary: null,
+    contextCompactedMessageCount: 0,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalEstimatedCost: 0,
+  }),
+  createConversation: () => ({ id: "conv-1" }),
+  addMessage: () => ({ id: `msg-${Date.now()}` }),
+  updateConversationUsage: () => {},
+  updateConversationTitle: () => {},
+}));
+
+mock.module("../memory/conversation-queries.js", () => ({
+  listConversations: () => [],
+}));
+
+mock.module("../memory/attachments-store.js", () => ({
+  uploadAttachment: () => ({ id: `att-${Date.now()}` }),
+  linkAttachmentToMessage: () => {},
+}));
+
+mock.module("../memory/retriever.js", () => ({
+  buildMemoryRecall: async () => ({
+    enabled: false,
+    degraded: false,
+    injectedText: "",
+    semanticHits: 0,
+    injectedTokens: 0,
+    latencyMs: 0,
+  }),
+  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
+}));
+
+mock.module("../context/window-manager.js", () => ({
+  ContextWindowManager: class {
+    constructor() {}
+    shouldCompact() {
+      return { needed: false, estimatedTokens: 0 };
+    }
+    async maybeCompact() {
+      return { compacted: false };
+    }
+  },
+  createContextSummaryMessage: () => ({
+    role: "user",
+    content: [{ type: "text", text: "summary" }],
+  }),
+  getSummaryFromContextMessage: () => null,
+}));
+
+mock.module("../memory/llm-usage-store.js", () => ({
+  recordUsageEvent: () => ({ id: "mock-id", createdAt: Date.now() }),
+  listUsageEvents: () => [],
+}));
+
+// Capture AgentLoop constructor config for assertions.
+let lastAgentLoopConfig: Partial<AgentLoopConfig> | undefined;
+
+mock.module("../agent/loop.js", () => ({
+  AgentLoop: class {
+    constructor(
+      _provider: unknown,
+      _systemPrompt: string,
+      config?: Partial<AgentLoopConfig>,
+    ) {
+      lastAgentLoopConfig = config;
+    }
+    getToolTokenBudget() {
+      return 0;
+    }
+    async run(
+      _messages: Message[],
+      _onEvent: (event: AgentEvent) => void,
+      _signal?: AbortSignal,
+      _requestId?: string,
+      _onCheckpoint?: (checkpoint: CheckpointInfo) => CheckpointDecision,
+    ): Promise<Message[]> {
+      return [];
+    }
+  },
+}));
+
+mock.module("../memory/canonical-guardian-store.js", () => ({
+  listPendingCanonicalGuardianRequestsByDestinationConversation: () => [],
+  listCanonicalGuardianRequests: () => [],
+  listPendingRequestsByConversationScope: () => [],
+  createCanonicalGuardianRequest: () => ({
+    id: "mock-cg-id",
+    code: "MOCK",
+    status: "pending",
+  }),
+  getCanonicalGuardianRequest: () => null,
+  getCanonicalGuardianRequestByCode: () => null,
+  updateCanonicalGuardianRequest: () => {},
+  resolveCanonicalGuardianRequest: () => {},
+  createCanonicalGuardianDelivery: () => ({ id: "mock-cgd-id" }),
+  listCanonicalGuardianDeliveries: () => [],
+  listPendingCanonicalGuardianRequestsByDestinationChat: () => [],
+  updateCanonicalGuardianDelivery: () => {},
+  generateCanonicalRequestCode: () => "MOCK-CODE",
+}));
+
+// ---------------------------------------------------------------------------
+// Import Conversation AFTER mocks
+// ---------------------------------------------------------------------------
+
+import { Conversation } from "../daemon/conversation.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeProvider() {
+  return {
+    name: "mock",
+    async sendMessage(): Promise<ProviderResponse> {
+      return {
+        content: [],
+        model: "mock",
+        usage: { inputTokens: 0, outputTokens: 0 },
+        stopReason: "end_turn",
+      };
+    },
+  };
+}
+
+function makeSendToClient(): (msg: ServerMessage) => void {
+  return () => {};
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("per-conversation speed override", () => {
+  test("speedOverride 'standard' prevents fast mode even when global config is 'fast'", () => {
+    mockConfigSpeed = "fast";
+    lastAgentLoopConfig = undefined;
+
+    new Conversation(
+      "conv-speed-override-1",
+      makeProvider(),
+      "system prompt",
+      4096,
+      makeSendToClient(),
+      "/tmp",
+      undefined, // broadcastToAllClients
+      undefined, // memoryPolicy
+      undefined, // sharedCesClient
+      "standard", // speedOverride
+    );
+
+    expect(lastAgentLoopConfig).toBeDefined();
+    // When speedOverride is "standard", the AgentLoop should NOT receive speed: "fast"
+    expect(lastAgentLoopConfig!.speed).toBeUndefined();
+  });
+
+  test("no speedOverride uses global config speed", () => {
+    mockConfigSpeed = "fast";
+    lastAgentLoopConfig = undefined;
+
+    new Conversation(
+      "conv-speed-global-1",
+      makeProvider(),
+      "system prompt",
+      4096,
+      makeSendToClient(),
+      "/tmp",
+      undefined, // broadcastToAllClients
+      undefined, // memoryPolicy
+      undefined, // sharedCesClient
+      // no speedOverride — should fall back to global config "fast"
+    );
+
+    expect(lastAgentLoopConfig).toBeDefined();
+    expect(lastAgentLoopConfig!.speed).toBe("fast");
+  });
+
+  test("speedOverride 'fast' enables fast mode even when global config is 'standard'", () => {
+    mockConfigSpeed = "standard";
+    lastAgentLoopConfig = undefined;
+
+    new Conversation(
+      "conv-speed-override-fast-1",
+      makeProvider(),
+      "system prompt",
+      4096,
+      makeSendToClient(),
+      "/tmp",
+      undefined, // broadcastToAllClients
+      undefined, // memoryPolicy
+      undefined, // sharedCesClient
+      "fast", // speedOverride
+    );
+
+    expect(lastAgentLoopConfig).toBeDefined();
+    expect(lastAgentLoopConfig!.speed).toBe("fast");
+  });
+});

package/src/__tests__/conversation-starter-routes.test.ts

@@ -1,25 +1,7 @@
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { v4 as uuid } from "uuid";
 
-const testDir = mkdtempSync(
-  join(tmpdir(), "conversation-starter-routes-test-"),
-);
-
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => testDir,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => join(testDir, "test.db"),
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -37,11 +19,6 @@ initializeDb();
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 const routes = conversationStarterRouteDefinitions();