@vellumai/assistant 0.7.2 → 0.7.3

package/src/__tests__/prechat-onboarding-contract.test.ts

@@ -153,25 +153,18 @@ describe("pre-chat onboarding contract", () => {
       const result = buildSystemPrompt({ onboardingContext: context });
       const dynamic = dynamicBlock(result);
 
-      expect(dynamic).toContain("## Pre-chat Onboarding Context");
+      expect(dynamic).toContain("## First-Run User Context");
       expect(dynamic).toContain(
-        "The user completed the native pre-chat onboarding.",
-      );
-      expect(dynamic).toContain('"tools"');
-      expect(dynamic).toContain('"slack"');
-      expect(dynamic).toContain('"linear"');
-      expect(dynamic).toContain('"tasks"');
-      expect(dynamic).toContain('"code-building"');
-      expect(dynamic).toContain('"tone": "warm"');
-      expect(dynamic).toContain('"userName": "Alex"');
-      expect(dynamic).toContain('"assistantName": "Nova"');
-      expect(dynamic).toContain("```json");
-      expect(dynamic).toContain(
-        "Use this to personalize your opener and skip redundant discovery.",
-      );
-      expect(dynamic).toContain(
-        "If `assistantName` is present, it is the name the user chose for you; preserve it in IDENTITY.md.",
+        "The user completed setup before this conversation.",
       );
+      expect(dynamic).toContain("- Daily tools: Slack, Linear");
+      expect(dynamic).toContain("- Common work: builds code, apps, or tools");
+      expect(dynamic).toContain("- Name: Alex");
+      expect(dynamic).toContain("- Chosen assistant name: Nova");
+      expect(dynamic).toContain("Apply this context quietly.");
+
+      // Raw JSON must NOT be present
+      expect(dynamic).not.toContain("```json");
     });
 
     test("does NOT inject onboarding context when BOOTSTRAP.md does not exist", () => {
@@ -186,9 +179,9 @@ describe("pre-chat onboarding contract", () => {
       const result = buildSystemPrompt({ onboardingContext: context });
       const dynamic = dynamicBlock(result);
 
-      expect(dynamic).not.toContain("## Pre-chat Onboarding Context");
-      expect(dynamic).not.toContain("pre-chat onboarding");
-      expect(dynamic).not.toContain('"tools"');
+      expect(dynamic).not.toContain("## First-Run User Context");
+      expect(dynamic).not.toContain("First-Run User Context");
+      expect(dynamic).not.toContain("- Daily tools:");
     });
 
     test("does NOT inject onboarding context when excludeBootstrap is true", () => {
@@ -209,7 +202,7 @@ describe("pre-chat onboarding contract", () => {
       });
       const dynamic = dynamicBlock(result);
 
-      expect(dynamic).not.toContain("## Pre-chat Onboarding Context");
+      expect(dynamic).not.toContain("## First-Run User Context");
       expect(dynamic).not.toContain("First-Run Ritual");
     });
 
@@ -225,7 +218,7 @@ describe("pre-chat onboarding contract", () => {
       // Bootstrap should still be present
       expect(dynamic).toContain("First-Run Ritual");
       // But no onboarding context section
-      expect(dynamic).not.toContain("## Pre-chat Onboarding Context");
+      expect(dynamic).not.toContain("## First-Run User Context");
     });
 
     test("accepts all four personality tones", () => {
@@ -247,12 +240,12 @@ describe("pre-chat onboarding contract", () => {
         const result = buildSystemPrompt({ onboardingContext: context });
         const dynamic = dynamicBlock(result);
 
-        expect(dynamic).toContain("## Pre-chat Onboarding Context");
-        expect(dynamic).toContain(`"tone": "${tone}"`);
+        expect(dynamic).toContain("## First-Run User Context");
+        expect(dynamic).toContain(`- Preferred initial voice: ${tone}`);
       }
     });
 
-    test("serializes onboarding context as pretty-printed JSON", () => {
+    test("renders compact markdown, not JSON", () => {
       writeFileSync(
         join(TEST_DIR, "BOOTSTRAP.md"),
         "# Bootstrap\n\nOnboarding.",
@@ -269,9 +262,65 @@ describe("pre-chat onboarding contract", () => {
       const result = buildSystemPrompt({ onboardingContext: context });
       const dynamic = dynamicBlock(result);
 
-      // Verify it contains the pretty-printed JSON (indented with 2 spaces)
+      // Should contain compact markdown lines
+      expect(dynamic).toContain("## First-Run User Context");
+      expect(dynamic).toContain("- Name: Jane");
+      expect(dynamic).toContain("- Common work: plans and coordinates work");
+      expect(dynamic).toContain("- Daily tools: Notion");
+      expect(dynamic).toContain("- Chosen assistant name: Kit");
+      expect(dynamic).toContain("- Preferred initial voice: warm");
+
+      // Must NOT contain JSON output
+      expect(dynamic).not.toContain("```json");
       const expectedJson = JSON.stringify(context, null, 2);
-      expect(dynamic).toContain(expectedJson);
+      expect(dynamic).not.toContain(expectedJson);
+    });
+
+    test("empty tools/tasks arrays result in no Daily tools / Common work lines", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# Bootstrap\n\nOnboarding.",
+      );
+
+      const context: OnboardingContext = {
+        tools: [],
+        tasks: [],
+        tone: "warm",
+        userName: "Alex",
+      };
+
+      const result = buildSystemPrompt({ onboardingContext: context });
+      const dynamic = dynamicBlock(result);
+
+      expect(dynamic).toContain("## First-Run User Context");
+      expect(dynamic).toContain("- Name: Alex");
+      expect(dynamic).not.toContain("- Daily tools:");
+      expect(dynamic).not.toContain("- Common work:");
+    });
+
+    test("absent userName results in no Name line", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# Bootstrap\n\nOnboarding.",
+      );
+
+      const context: OnboardingContext = {
+        tools: ["slack"],
+        tasks: ["writing"],
+        tone: "warm",
+      };
+
+      const result = buildSystemPrompt({ onboardingContext: context });
+      const dynamic = dynamicBlock(result);
+
+      expect(dynamic).toContain("## First-Run User Context");
+      expect(dynamic).not.toContain("- Name:");
+      // Other fields should still be present
+      expect(dynamic).toContain("- Daily tools: Slack");
+      expect(dynamic).toContain(
+        "- Common work: writes docs, emails, or content",
+      );
+      expect(dynamic).toContain("- Preferred initial voice: warm");
     });
   });
 
@@ -290,4 +339,142 @@ describe("pre-chat onboarding contract", () => {
       expect(true).toBe(true); // structural acknowledgment
     });
   });
+
+  describe("end-to-end onboarding integration", () => {
+    test("with BOOTSTRAP.md present, onboarding context produces compact markdown with normalized labels", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# Bootstrap\n\nWelcome to your first conversation.",
+      );
+
+      const context: OnboardingContext = {
+        tools: ["slack", "notion", "linear"],
+        tasks: ["code-building", "writing", "project-management"],
+        tone: "grounded",
+        userName: "Alice",
+        assistantName: "Pax",
+      };
+
+      const result = buildSystemPrompt({ onboardingContext: context });
+      const dynamic = dynamicBlock(result);
+
+      // Heading is present
+      expect(dynamic).toContain("## First-Run User Context");
+
+      // Normalized labels appear (capitalised tool names, human-readable task descriptions)
+      expect(dynamic).toContain("- Daily tools: Slack, Notion, Linear");
+      expect(dynamic).toContain("- Name: Alice");
+      expect(dynamic).toContain("- Chosen assistant name: Pax");
+      expect(dynamic).toContain("- Preferred initial voice: grounded");
+      // Common work descriptions are normalised from task IDs
+      expect(dynamic).toContain("- Common work:");
+
+      // No raw JSON anywhere in the dynamic block
+      expect(dynamic).not.toContain("```json");
+      expect(dynamic).not.toContain('"tools"');
+      expect(dynamic).not.toContain('"tasks"');
+      expect(dynamic).not.toContain('"tone"');
+      expect(dynamic).not.toContain('"userName"');
+      expect(dynamic).not.toContain('"assistantName"');
+    });
+
+    test("without BOOTSTRAP.md, onboarding context does NOT appear in system prompt", () => {
+      // No BOOTSTRAP.md created — simulates a returning user session
+      const context: OnboardingContext = {
+        tools: ["slack", "figma"],
+        tasks: ["design", "writing"],
+        tone: "warm",
+        userName: "Bob",
+        assistantName: "Kit",
+      };
+
+      const result = buildSystemPrompt({ onboardingContext: context });
+      const dynamic = dynamicBlock(result);
+
+      // Onboarding section must be absent
+      expect(dynamic).not.toContain("## First-Run User Context");
+      expect(dynamic).not.toContain("First-Run Ritual");
+      expect(dynamic).not.toContain("- Daily tools:");
+      expect(dynamic).not.toContain("- Name: Bob");
+      expect(dynamic).not.toContain("- Chosen assistant name:");
+      expect(dynamic).not.toContain("Apply this context quietly.");
+    });
+
+    test("excludeBootstrap suppresses both bootstrap and onboarding sections", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# Bootstrap\n\nFirst run instructions.",
+      );
+
+      const context: OnboardingContext = {
+        tools: ["linear"],
+        tasks: ["code-building"],
+        tone: "energetic",
+        userName: "Charlie",
+        assistantName: "Nova",
+      };
+
+      const result = buildSystemPrompt({
+        onboardingContext: context,
+        excludeBootstrap: true,
+      });
+      const dynamic = dynamicBlock(result);
+
+      // Both bootstrap and onboarding must be suppressed
+      expect(dynamic).not.toContain("First-Run Ritual");
+      expect(dynamic).not.toContain("## First-Run User Context");
+      expect(dynamic).not.toContain("- Daily tools:");
+      expect(dynamic).not.toContain("- Name: Charlie");
+      expect(dynamic).not.toContain("Apply this context quietly.");
+    });
+
+    test("userPersona is included independently of onboarding context", () => {
+      // No BOOTSTRAP.md — the durable persona path after bootstrap is deleted
+      const personaContent =
+        "# User Persona\n\nPrefers concise answers. Works in fintech.";
+
+      const result = buildSystemPrompt({
+        userPersona: personaContent,
+        // No onboardingContext — simulates post-onboarding conversation
+      });
+      const dynamic = dynamicBlock(result);
+
+      // Persona content appears in prompt even without bootstrap or onboarding
+      expect(dynamic).toContain("# User Persona");
+      expect(dynamic).toContain("Prefers concise answers. Works in fintech.");
+
+      // No onboarding section should be present
+      expect(dynamic).not.toContain("## First-Run User Context");
+      expect(dynamic).not.toContain("First-Run Ritual");
+    });
+
+    test("userPersona appears alongside onboarding context during first run", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# Bootstrap\n\nOnboarding flow.",
+      );
+
+      const personaContent =
+        "# User Persona\n\nEarly-stage startup founder. Likes bullet points.";
+      const context: OnboardingContext = {
+        tools: ["slack"],
+        tasks: ["writing"],
+        tone: "warm",
+        userName: "Dana",
+      };
+
+      const result = buildSystemPrompt({
+        userPersona: personaContent,
+        onboardingContext: context,
+      });
+      const dynamic = dynamicBlock(result);
+
+      // Both persona and onboarding context appear
+      expect(dynamic).toContain("# User Persona");
+      expect(dynamic).toContain("Likes bullet points.");
+      expect(dynamic).toContain("## First-Run User Context");
+      expect(dynamic).toContain("- Name: Dana");
+      expect(dynamic).toContain("- Daily tools: Slack");
+    });
+  });
 });

package/src/__tests__/provider-tool-name.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  isProviderSafeToolName,
+  toProviderSafeToolName,
+} from "../tools/provider-tool-name.js";
+
+describe("provider tool names", () => {
+  test("leaves already-safe names unchanged", () => {
+    expect(toProviderSafeToolName("deploy")).toBe("deploy");
+    expect(isProviderSafeToolName("deploy")).toBe(true);
+  });
+
+  test("preserves raw-name identity for names that differ by edge whitespace", () => {
+    const plain = toProviderSafeToolName("deploy");
+    const padded = toProviderSafeToolName(" deploy ");
+
+    expect(plain).toBe("deploy");
+    expect(padded).toMatch(/^deploy__[a-f0-9]{12}$/);
+    expect(padded).not.toBe(plain);
+    expect(isProviderSafeToolName(padded)).toBe(true);
+  });
+});

package/src/__tests__/relay-server.test.ts

@@ -362,11 +362,22 @@ function getLatestAssistantText(conversationId: string): string | null {
     if (Array.isArray(parsed)) {
       return parsed
         .filter(
-          (block): block is { type: string; text?: string } =>
-            typeof block === "object" && block != null,
+          (block): block is {
+            type: string;
+            text?: string;
+            surfaceType?: string;
+            data?: { summaryText?: string };
+          } => typeof block === "object" && block != null,
         )
-        .filter((block) => block.type === "text")
-        .map((block) => block.text ?? "")
+        .map((block) => {
+          if (block.type === "text") return block.text ?? "";
+          if (
+            block.type === "ui_surface" &&
+            block.surfaceType === "call_summary"
+          )
+            return block.data?.summaryText ?? "";
+          return "";
+        })
         .join("");
     }
     if (typeof parsed === "string") return parsed;

package/src/__tests__/runtime-events-sse.test.ts

@@ -135,12 +135,10 @@ describe("SSE assistant-events endpoint", () => {
     // Read the first frame directly from the stream.
     const reader = stream.getReader();
 
-    // The first chunk is the immediate heartbeat (comment + data event) enqueued in start().
+    // The first chunk is the immediate heartbeat comment enqueued in start().
     const initial = await reader.read();
     expect(initial.done).toBe(false);
-    const initialText = new TextDecoder().decode(initial.value);
-    expect(initialText).toContain(": heartbeat");
-    expect(initialText).toContain('{"type":"heartbeat"}');
+    expect(new TextDecoder().decode(initial.value)).toBe(": heartbeat\n\n");
 
     // The second chunk is the actual assistant event.
     const { value, done } = await reader.read();
@@ -172,12 +170,10 @@ describe("SSE assistant-events endpoint", () => {
 
     const reader = stream.getReader();
 
-    // Consume the initial heartbeat (comment + data event).
+    // Consume the initial heartbeat.
     const heartbeat = await reader.read();
     expect(heartbeat.done).toBe(false);
-    const heartbeatText = new TextDecoder().decode(heartbeat.value);
-    expect(heartbeatText).toContain(": heartbeat");
-    expect(heartbeatText).toContain('{"type":"heartbeat"}');
+    expect(new TextDecoder().decode(heartbeat.value)).toBe(": heartbeat\n\n");
 
     // Publish events with two different conversationIds.
     const eventA = buildAssistantEvent({ type: "pong" }, "conversation-aaa");

package/src/__tests__/scheduler-disk-pressure.test.ts

@@ -0,0 +1,148 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => ({
+    info: () => {},
+    debug: () => {},
+    warn: () => {},
+    error: () => {},
+  }),
+  truncateForLog: (value: string) => value,
+}));
+
+mock.module("../runtime/agent-wake.js", () => ({
+  wakeAgentForOpportunity: mock(() =>
+    Promise.resolve({ invoked: true, producedToolCalls: false }),
+  ),
+}));
+
+mock.module("../home/emit-feed-event.js", () => ({
+  emitFeedEvent: mock(() => Promise.resolve()),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({}),
+  loadConfig: () => ({}),
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  getConfigReadOnly: () => ({}),
+  applyNestedDefaults: (config: unknown) => config,
+  deepMergeOverwrite: (base: unknown) => base,
+  mergeDefaultWorkspaceConfig: () => {},
+  getNestedValue: () => undefined,
+  setNestedValue: () => {},
+  API_KEY_PROVIDERS: [],
+  _appendQuarantineBulletin: () => {},
+  invalidateConfigCache: () => {},
+}));
+
+let locked = true;
+mock.module("../daemon/disk-pressure-background-gate.js", () => ({
+  checkDiskPressureBackgroundGate: () =>
+    locked
+      ? {
+          action: "skip",
+          reason: "disk_pressure",
+          blockedCapability: "background-work",
+          status: {
+            enabled: true,
+            state: "critical",
+            locked: true,
+            acknowledged: true,
+            overrideActive: false,
+            effectivelyLocked: true,
+            lockId: "disk-pressure-test",
+            usagePercent: 98,
+            thresholdPercent: 95,
+            path: "/",
+            lastCheckedAt: "2026-05-05T00:00:00.000Z",
+            blockedCapabilities: [
+              "agent-turns",
+              "background-work",
+              "remote-ingress",
+            ],
+            error: null,
+          },
+        }
+      : {
+          action: "allow",
+          status: {
+            enabled: false,
+            state: "disabled",
+            locked: false,
+            acknowledged: false,
+            overrideActive: false,
+            effectivelyLocked: false,
+            lockId: null,
+            usagePercent: null,
+            thresholdPercent: 95,
+            path: null,
+            lastCheckedAt: null,
+            blockedCapabilities: [],
+            error: null,
+          },
+        },
+  diskPressureBackgroundSkipLogFields: () => ({
+    reason: "disk_pressure",
+    thresholdPercent: 95,
+    usagePercent: 98,
+    blockedCapability: "background-work",
+    lockId: "disk-pressure-test",
+    path: "/",
+  }),
+  shouldLogDiskPressureBackgroundSkip: () => true,
+}));
+
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { createSchedule } from "../schedule/schedule-store.js";
+import { runScheduleOnce } from "../schedule/scheduler.js";
+
+initializeDb();
+
+function rawDb(): import("bun:sqlite").Database {
+  return (getDb() as unknown as { $client: import("bun:sqlite").Database })
+    .$client;
+}
+
+describe("scheduler disk pressure gate", () => {
+  beforeEach(() => {
+    locked = true;
+    const db = getDb();
+    db.run("DELETE FROM cron_runs");
+    db.run("DELETE FROM cron_jobs");
+    db.run("DELETE FROM task_runs");
+    db.run("DELETE FROM tasks");
+    db.run("DELETE FROM messages");
+    db.run("DELETE FROM conversations");
+  });
+
+  test("skips before claiming due schedules while disk pressure is locked", async () => {
+    const dueAt = Date.now() - 10_000;
+    const schedule = createSchedule({
+      name: "Due reminder",
+      message: "Do not fire while locked",
+      mode: "notify",
+      nextRunAt: dueAt,
+    });
+
+    const processMessage = mock(() => Promise.resolve());
+    const notify = mock(() => Promise.resolve());
+
+    const processed = await runScheduleOnce(processMessage, notify);
+
+    expect(processed).toBe(0);
+    expect(processMessage).not.toHaveBeenCalled();
+    expect(notify).not.toHaveBeenCalled();
+
+    const row = rawDb()
+      .query("SELECT status, next_run_at FROM cron_jobs WHERE id = ?")
+      .get(schedule.id) as { status: string; next_run_at: number } | null;
+    expect(row).toEqual({ status: "active", next_run_at: dueAt });
+
+    const runCount = rawDb()
+      .query("SELECT COUNT(*) AS count FROM cron_runs")
+      .get() as { count: number };
+    expect(runCount.count).toBe(0);
+  });
+});

package/src/__tests__/secret-ingress-http.test.ts

@@ -106,7 +106,6 @@ mock.module("../memory/conversation-crud.js", () => ({
   provenanceFromTrustContext: () => undefined,
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
-  getConversationMemoryScopeId: () => undefined,
 }));
 
 mock.module("../runtime/local-actor-identity.js", () => ({

package/src/__tests__/suggestion-routes.test.ts

@@ -561,6 +561,52 @@ describe("GET /v1/suggestion", () => {
     expect(options?.config?.callSite).toBe("conversationStarters");
   });
 
+  test("disables thinking and zeros effort to avoid Anthropic temp/thinking 400", async () => {
+    // Regression guard: this call hardcodes `temperature: 0.7` for response
+    // variety. Anthropic 400s on `temperature` ≠ 1 whenever thinking is
+    // enabled or in adaptive mode, so any user profile that resolves
+    // thinking-enabled (Opus 4.x at `effort: high|xhigh`, etc.) would fail
+    // unless we explicitly opt out of thinking on this call site.
+    //
+    // Pinning `thinking: { type: "disabled" }` and `effort: "none"` ensures
+    // the call works on every profile shape. A 60-token reply chip doesn't
+    // benefit from extended thinking anyway.
+    const provider = makeMockProvider("Quick reply");
+    mockGetConfiguredProvider.mockImplementation(async () => provider);
+    mockGetConversationByKey.mockImplementation(() => ({
+      conversationId: "conv-test",
+    }));
+    mockGetMessages.mockImplementation(() => [
+      {
+        id: "msg-asst-thinking",
+        conversationId: "conv-test",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Hello!" }]),
+        createdAt: Date.now(),
+        metadata: null,
+      },
+    ]);
+
+    const args = makeArgs({ conversationKey: "test-key" });
+    const deps = makeDeps();
+    await handleGetSuggestion(args, deps);
+
+    expect(provider.sendMessage).toHaveBeenCalledTimes(1);
+    const callArgs = provider.sendMessage.mock.calls[0] as unknown[];
+    const options = callArgs[3] as
+      | {
+          config?: {
+            temperature?: number;
+            thinking?: { type?: string };
+            effort?: string;
+          };
+        }
+      | undefined;
+    expect(options?.config?.temperature).toBe(0.7);
+    expect(options?.config?.thinking).toEqual({ type: "disabled" });
+    expect(options?.config?.effort).toBe("none");
+  });
+
   test("does not send an assistant-role prefill message", async () => {
     // Regression guard: Anthropic rejects assistant-message prefill
     // whenever the request triggers extended thinking (e.g. Opus 4.x at

package/src/__tests__/twilio-validation.test.ts

@@ -49,7 +49,7 @@ describe("Twilio validation middleware", () => {
     };
   });
 
-  test("validates signatures against Twilio-specific public ingress first", async () => {
+  test("validates signatures against configured public ingress", async () => {
     mockConfig = {
       ingress: {
         publicBaseUrl: "  https://twilio.example.com///  ",
@@ -77,7 +77,7 @@ describe("Twilio validation middleware", () => {
     ]);
   });
 
-  test("falls back to generic public ingress when Twilio-specific ingress is empty", async () => {
+  test("uses configured public ingress for status callbacks", async () => {
     const req = new Request("http://127.0.0.1:7821/v1/calls/twilio/status", {
       method: "POST",
       headers: { "x-twilio-signature": "valid" },