@vellumai/assistant 0.6.0 → 0.6.2

package/src/__tests__/navigate-settings-tab.test.ts

@@ -14,7 +14,7 @@ const CANONICAL_TABS = [
   "Sounds",
   "Permissions & Privacy",
   "Billing",
-  "Archived Conversations",
+  "Archive",
   "Schedules",
   "Developer",
 ];
@@ -85,4 +85,17 @@ describe("navigate-settings-tab", () => {
     expect(result.isError).toBe(false);
     expect(result.content).toContain("Developer");
   });
+
+  test("normalizes legacy 'Archived Conversations' alias to 'Archive'", async () => {
+    const messages: unknown[] = [];
+    const result = await run(
+      { tab: "Archived Conversations" },
+      makeContext((msg) => messages.push(msg)),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Archive");
+    expect(messages).toHaveLength(1);
+    expect(messages[0]).toEqual({ type: "navigate_settings", tab: "Archive" });
+  });
 });

package/src/__tests__/notification-broadcaster.test.ts

@@ -583,4 +583,69 @@ describe("notification broadcaster", () => {
     expect(vellumCall).toBeDefined();
     expect(vellumCall!.options?.bindingContext).toBeUndefined();
   });
+
+  // ── conversationMetadata propagation ──────────────────────────────
+
+  test("onConversationCreated includes groupId and source from conversationMetadata", async () => {
+    const vellumAdapter = new MockAdapter("vellum");
+    const broadcaster = new NotificationBroadcaster([vellumAdapter]);
+    const createdCalls: ConversationCreatedInfo[] = [];
+    broadcaster.setOnConversationCreated((info) => createdCalls.push(info));
+
+    const signal = makeSignal({
+      sourceEventName: "schedule.complete",
+      conversationMetadata: {
+        groupId: "system:scheduled",
+        source: "schedule",
+        scheduleJobId: "job-abc-123",
+      },
+    });
+    const decision = makeDecision();
+
+    await broadcaster.broadcastDecision(signal, decision);
+
+    expect(createdCalls).toHaveLength(1);
+    expect(createdCalls[0].groupId).toBe("system:scheduled");
+    expect(createdCalls[0].source).toBe("schedule");
+    expect(createdCalls[0].sourceEventName).toBe("schedule.complete");
+  });
+
+  test("onConversationCreated omits groupId and source when conversationMetadata is absent", async () => {
+    const vellumAdapter = new MockAdapter("vellum");
+    const broadcaster = new NotificationBroadcaster([vellumAdapter]);
+    const createdCalls: ConversationCreatedInfo[] = [];
+    broadcaster.setOnConversationCreated((info) => createdCalls.push(info));
+
+    const signal = makeSignal(); // no conversationMetadata
+    const decision = makeDecision();
+
+    await broadcaster.broadcastDecision(signal, decision);
+
+    expect(createdCalls).toHaveLength(1);
+    expect(createdCalls[0].groupId).toBeUndefined();
+    expect(createdCalls[0].source).toBeUndefined();
+  });
+
+  test("per-dispatch callback receives conversationMetadata fields", async () => {
+    const vellumAdapter = new MockAdapter("vellum");
+    const broadcaster = new NotificationBroadcaster([vellumAdapter]);
+    const dispatchCalls: ConversationCreatedInfo[] = [];
+
+    const signal = makeSignal({
+      sourceEventName: "schedule.complete",
+      conversationMetadata: {
+        groupId: "system:scheduled",
+        source: "schedule",
+      },
+    });
+    const decision = makeDecision();
+
+    await broadcaster.broadcastDecision(signal, decision, {
+      onConversationCreated: (info) => dispatchCalls.push(info),
+    });
+
+    expect(dispatchCalls).toHaveLength(1);
+    expect(dispatchCalls[0].groupId).toBe("system:scheduled");
+    expect(dispatchCalls[0].source).toBe("schedule");
+  });
 });

package/src/__tests__/notification-decision-recipient-context.test.ts

@@ -0,0 +1,282 @@
+/**
+ * Tests for recipient context (guardian contact notes) injection in the
+ * notification decision engine.
+ *
+ * Validates that guardian contact notes appear in the LLM system prompt as
+ * a <recipient-context> block when available, are omitted when absent or
+ * empty, and are truncated when large.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Mocks (must precede imports from mocked modules) ──────────────────
+
+mock.module("../channels/config.js", () => ({
+  getDeliverableChannels: () => ["vellum"],
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    notifications: {
+      decisionModelIntent: "latency-optimized",
+    },
+  }),
+}));
+
+mock.module("../notifications/decisions-store.js", () => ({
+  createDecision: () => {},
+}));
+
+mock.module("../notifications/preference-summary.js", () => ({
+  getPreferenceSummary: () => undefined,
+}));
+
+mock.module("../notifications/conversation-candidates.js", () => ({
+  buildConversationCandidates: () => undefined,
+  serializeCandidatesForPrompt: () => undefined,
+}));
+
+mock.module("../prompts/persona-resolver.js", () => ({
+  resolveGuardianPersona: () => null,
+}));
+
+mock.module("../prompts/system-prompt.js", () => ({
+  buildCoreIdentityContext: () => null,
+}));
+
+// ── Guardian contact mock ────────────────────────────────────────────
+
+let mockGuardianResult: {
+  contact: { notes: string | null };
+  channels: Record<string, unknown>[];
+} | null = null;
+
+mock.module("../contacts/contact-store.js", () => ({
+  listGuardianChannels: () => mockGuardianResult,
+}));
+
+// ── Provider mock with system prompt capture ──────────────────────────
+
+let configuredProvider: {
+  sendMessage: (...args: unknown[]) => Promise<unknown>;
+} | null = null;
+let extractedToolUse: unknown = null;
+let capturedSystemPrompt: string | undefined;
+
+mock.module("../providers/provider-send-message.js", () => ({
+  getConfiguredProvider: async () => configuredProvider,
+  createTimeout: () => ({
+    signal: new AbortController().signal,
+    cleanup: () => {},
+  }),
+  extractToolUse: () => extractedToolUse,
+  userMessage: (text: string) => ({ role: "user", content: text }),
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// ── Imports (after all mocks) ─────────────────────────────────────────
+
+import { evaluateSignal } from "../notifications/decision-engine.js";
+import type { NotificationSignal } from "../notifications/signal.js";
+import type { NotificationChannel } from "../notifications/types.js";
+
+// ── Helpers ───────────────────────────────────────────────────────────
+
+function makeSignal(
+  overrides?: Partial<NotificationSignal>,
+): NotificationSignal {
+  return {
+    signalId: "sig-recipient-ctx-test-1",
+    createdAt: Date.now(),
+    sourceChannel: "phone",
+    sourceContextId: "call-session-1",
+    sourceEventName: "guardian.question",
+    contextPayload: {
+      questionText: "What is the gate code?",
+    },
+    attentionHints: {
+      requiresAction: true,
+      urgency: "high",
+      isAsyncBackground: false,
+      visibleInSourceNow: false,
+    },
+    ...overrides,
+  };
+}
+
+function setupLLMProvider() {
+  configuredProvider = {
+    sendMessage: async (
+      _messages: unknown,
+      _tools: unknown,
+      systemPrompt: unknown,
+    ) => {
+      capturedSystemPrompt = systemPrompt as string;
+      return { content: [] };
+    },
+  };
+  extractedToolUse = {
+    name: "record_notification_decision",
+    input: {
+      shouldNotify: true,
+      selectedChannels: ["vellum"],
+      reasoningSummary: "LLM decision with recipient context",
+      renderedCopy: {
+        vellum: {
+          title: "Guardian Question",
+          body: "What is the gate code?",
+        },
+      },
+      dedupeKey: "recipient-ctx-test",
+      confidence: 0.9,
+    },
+  };
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────
+
+describe("recipient context in notification decision engine", () => {
+  beforeEach(() => {
+    configuredProvider = null;
+    extractedToolUse = null;
+    mockGuardianResult = null;
+    capturedSystemPrompt = undefined;
+  });
+
+  test("guardian contact notes appear in system prompt as <recipient-context>", async () => {
+    mockGuardianResult = {
+      contact: { notes: "Prefers formal tone. Address as Dr. Smith." },
+      channels: [{ type: "vellum" }],
+    };
+    setupLLMProvider();
+
+    const signal = makeSignal();
+    await evaluateSignal(signal, ["vellum"] as NotificationChannel[]);
+
+    expect(capturedSystemPrompt).toBeDefined();
+    expect(capturedSystemPrompt).toContain("<recipient-context>");
+    expect(capturedSystemPrompt).toContain(
+      "Prefers formal tone. Address as Dr. Smith.",
+    );
+    expect(capturedSystemPrompt).toContain("</recipient-context>");
+  });
+
+  test("recipient-context is omitted when no guardian exists", async () => {
+    mockGuardianResult = null;
+    setupLLMProvider();
+
+    const signal = makeSignal();
+    await evaluateSignal(signal, ["vellum"] as NotificationChannel[]);
+
+    expect(capturedSystemPrompt).toBeDefined();
+    expect(capturedSystemPrompt).not.toContain("<recipient-context>");
+    expect(capturedSystemPrompt).not.toContain("</recipient-context>");
+  });
+
+  test("recipient-context is omitted when guardian notes are null", async () => {
+    mockGuardianResult = {
+      contact: { notes: null },
+      channels: [{ type: "vellum" }],
+    };
+    setupLLMProvider();
+
+    const signal = makeSignal();
+    await evaluateSignal(signal, ["vellum"] as NotificationChannel[]);
+
+    expect(capturedSystemPrompt).toBeDefined();
+    expect(capturedSystemPrompt).not.toContain("<recipient-context>");
+    expect(capturedSystemPrompt).not.toContain("</recipient-context>");
+  });
+
+  test("recipient-context is omitted when guardian notes are empty string", async () => {
+    mockGuardianResult = {
+      contact: { notes: "" },
+      channels: [{ type: "vellum" }],
+    };
+    setupLLMProvider();
+
+    const signal = makeSignal();
+    await evaluateSignal(signal, ["vellum"] as NotificationChannel[]);
+
+    expect(capturedSystemPrompt).toBeDefined();
+    expect(capturedSystemPrompt).not.toContain("<recipient-context>");
+    expect(capturedSystemPrompt).not.toContain("</recipient-context>");
+  });
+
+  test("large guardian notes are truncated to prevent oversized prompts", async () => {
+    mockGuardianResult = {
+      contact: { notes: "N".repeat(3000) },
+      channels: [{ type: "vellum" }],
+    };
+    setupLLMProvider();
+
+    const signal = makeSignal();
+    await evaluateSignal(signal, ["vellum"] as NotificationChannel[]);
+
+    expect(capturedSystemPrompt).toBeDefined();
+    expect(capturedSystemPrompt).toContain("<recipient-context>");
+    // Full 3000-char string should NOT appear
+    expect(capturedSystemPrompt).not.toContain("N".repeat(3000));
+    // Truncation marker should be present
+    expect(capturedSystemPrompt).toContain("\u2026[truncated]");
+
+    const match = capturedSystemPrompt!.match(
+      /<recipient-context>([\s\S]*?)<\/recipient-context>/,
+    );
+    expect(match).toBeTruthy();
+    const block = match![1];
+    expect(block).toContain("\u2026[truncated]");
+    // The notes portion within the block should not exceed 2000 chars
+    expect(block).not.toContain("N".repeat(2001));
+  });
+
+  test("fallback path works correctly without recipient context", async () => {
+    mockGuardianResult = {
+      contact: { notes: "Prefers formal tone." },
+      channels: [{ type: "vellum" }],
+    };
+    // null provider forces fallback path
+    configuredProvider = null;
+
+    const signal = makeSignal();
+    const decision = await evaluateSignal(signal, [
+      "vellum",
+    ] as NotificationChannel[]);
+
+    expect(decision.fallbackUsed).toBe(true);
+    expect(decision.shouldNotify).toBe(true);
+    expect(decision.renderedCopy.vellum?.title).toBeDefined();
+    expect(decision.renderedCopy.vellum?.body).toBeDefined();
+    // No LLM call, so no system prompt captured
+    expect(capturedSystemPrompt).toBeUndefined();
+  });
+
+  test("recipient-context appears after user-preferences in prompt", async () => {
+    mockGuardianResult = {
+      contact: { notes: "Prefers brief updates." },
+      channels: [{ type: "vellum" }],
+    };
+    setupLLMProvider();
+
+    const signal = makeSignal();
+    await evaluateSignal(
+      signal,
+      ["vellum"] as NotificationChannel[],
+      "Notify only for urgent items",
+    );
+
+    expect(capturedSystemPrompt).toBeDefined();
+    const prefsIdx = capturedSystemPrompt!.indexOf("</user-preferences>");
+    const recipientIdx = capturedSystemPrompt!.indexOf("<recipient-context>");
+    expect(prefsIdx).toBeGreaterThan(-1);
+    expect(recipientIdx).toBeGreaterThan(-1);
+    expect(recipientIdx).toBeGreaterThan(prefsIdx);
+  });
+});

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

@@ -4,6 +4,10 @@ import { describe, expect, test } from "bun:test";
 
 const templatesDir = join(import.meta.dirname, "..", "prompts", "templates");
 const bootstrap = readFileSync(join(templatesDir, "BOOTSTRAP.md"), "utf-8");
+const bootstrapRef = readFileSync(
+  join(templatesDir, "BOOTSTRAP-REFERENCE.md"),
+  "utf-8",
+);
 const identity = readFileSync(join(templatesDir, "IDENTITY.md"), "utf-8");
 const user = readFileSync(join(templatesDir, "USER.md"), "utf-8");
 
@@ -17,28 +21,32 @@ describe("onboarding template contracts", () => {
       const lower = bootstrap.toLowerCase();
       expect(lower).toContain("your name");
       expect(lower).toContain("personality");
-      expect(lower).toContain("avatar");
     });
 
-    test("infers personality organically instead of asking directly", () => {
+    test("leads with personality-first emotional arc", () => {
       const lower = bootstrap.toLowerCase();
       expect(lower).toContain("personality");
-      expect(lower).toContain("emerge");
       expect(lower).toContain("vibe");
+      // Personality arc should come before usefulness arc
+      const personalityIdx = lower.indexOf("oh, this has personality");
+      const usefulIdx = lower.indexOf("oh, this is useful");
+      expect(personalityIdx).toBeGreaterThan(-1);
+      expect(usefulIdx).toBeGreaterThan(-1);
+      expect(personalityIdx).toBeLessThan(usefulIdx);
     });
 
     test("contains name selection with change-later instruction", () => {
       const lower = bootstrap.toLowerCase();
-      expect(lower).toContain("what do you want to call me");
+      expect(lower).toContain("what they want to call you");
       expect(lower).toContain("change it later");
     });
 
-    test("asks about user after assistant identity", () => {
-      const nameIdx = bootstrap.indexOf("Your name");
-      const theirNameIdx = bootstrap.indexOf("Their name");
+    test("name exchange happens before personality quiz", () => {
+      const nameIdx = bootstrap.indexOf("Step 1: Name Exchange");
+      const quizIdx = bootstrap.indexOf("Step 2: Personality Quiz");
       expect(nameIdx).toBeGreaterThan(-1);
-      expect(theirNameIdx).toBeGreaterThan(-1);
-      expect(nameIdx).toBeLessThan(theirNameIdx);
+      expect(quizIdx).toBeGreaterThan(-1);
+      expect(nameIdx).toBeLessThan(quizIdx);
     });
 
     test("gathers user context: work role, hobbies, daily tools", () => {
@@ -48,18 +56,16 @@ describe("onboarding template contracts", () => {
       expect(lower).toContain("tools");
     });
 
-    test("shows exactly 2 suggestions via ui_show card with relay_prompt actions", () => {
+    test("references ui_show payloads from BOOTSTRAP-REFERENCE.md", () => {
       expect(bootstrap).toContain("ui_show");
-      expect(bootstrap).toContain("exactly 2");
-      expect(bootstrap).toContain("relay_prompt");
+      expect(bootstrap).toContain("BOOTSTRAP-REFERENCE.md");
     });
 
-    test("contains wrapping-up criteria with required conditions", () => {
+    test("contains wrapping-up criteria with deletion instructions", () => {
       const lower = bootstrap.toLowerCase();
       expect(lower).toContain("wrapping up");
       expect(lower).toContain("delete");
       expect(lower).toContain("bootstrap.md");
-      expect(lower).toContain("two suggestions");
     });
 
     test("contains refusal policy", () => {
@@ -83,6 +89,49 @@ describe("onboarding template contracts", () => {
       expect(bootstrap).toContain("SOUL.md");
       expect(bootstrap).toContain("file_edit");
     });
+
+    test("includes budget constraint", () => {
+      expect(bootstrap).toContain("$5");
+    });
+
+    test("includes new colleague framing", () => {
+      expect(bootstrap).toContain("new colleague");
+    });
+
+    test("instructs checking Connected Services for email task variant", () => {
+      expect(bootstrap).toContain("Connected Services");
+      expect(bootstrap).toContain("Connect my email");
+      expect(bootstrap).toContain("Check my email");
+    });
+
+    test("keeps momentum by chaining off the first task", () => {
+      const lower = bootstrap.toLowerCase();
+      expect(lower).toContain("keep the momentum");
+      expect(lower).toContain("don't pivot to setup");
+      expect(lower).toContain("chain off the task");
+      expect(lower).toContain("while we're at it");
+    });
+  });
+
+  describe("BOOTSTRAP-REFERENCE.md", () => {
+    test("contains personality form with 4 dropdowns", () => {
+      expect(bootstrapRef).toContain('surface_type: "form"');
+      expect(bootstrapRef).toContain("communication_style");
+      expect(bootstrapRef).toContain("task_style");
+      expect(bootstrapRef).toContain("humor");
+      expect(bootstrapRef).toContain("depth");
+    });
+
+    test("contains email-not-connected task card variant", () => {
+      expect(bootstrapRef).toContain("Email Not Connected");
+      expect(bootstrapRef).toContain("Connect my email");
+      expect(bootstrapRef).toContain("relay_prompt");
+    });
+
+    test("contains email-already-connected task card variant", () => {
+      expect(bootstrapRef).toContain("Email Already Connected");
+      expect(bootstrapRef).toContain("Check my email");
+    });
   });
 
   describe("IDENTITY.md", () => {

package/src/__tests__/parser.test.ts

@@ -177,6 +177,38 @@ describe("Shell Parser", () => {
           result.dangerousPatterns.some((p) => p.type === "pipe_to_shell"),
         ).toBe(false);
       });
+
+      test("pipe to python3 -c is not flagged (inline code, not stdin exec)", async () => {
+        const result = await parse(
+          'cat data.json | python3 -c "import sys; print(sys.stdin.read())"',
+        );
+        expect(
+          result.dangerousPatterns.some((p) => p.type === "pipe_to_shell"),
+        ).toBe(false);
+      });
+
+      test("pipe to node -e is not flagged (inline code)", async () => {
+        const result = await parse(
+          "cat data.json | node -e \"process.stdin.resume()\"",
+        );
+        expect(
+          result.dangerousPatterns.some((p) => p.type === "pipe_to_shell"),
+        ).toBe(false);
+      });
+
+      test("pipe to python3 without flags is flagged (stdin exec)", async () => {
+        const result = await parse("cat exploit.py | python3");
+        expect(
+          result.dangerousPatterns.some((p) => p.type === "pipe_to_shell"),
+        ).toBe(true);
+      });
+
+      test("pipe to python3 - is flagged (explicit stdin exec)", async () => {
+        const result = await parse("cat exploit.py | python3 -");
+        expect(
+          result.dangerousPatterns.some((p) => p.type === "pipe_to_shell"),
+        ).toBe(true);
+      });
     });
 
     // base64_execute