@vellumai/assistant 0.8.11 → 0.8.12-staging.2

package/src/__tests__/filing-service.test.ts

@@ -96,9 +96,14 @@ mock.module("../util/logger.js", () => ({
   }),
 }));
 
-// Mock conversation title service
+// Mock conversation title service. `deriveDeterministicTitle` mirrors the
+// real implementation's systemHint passthrough so bootstrap-created
+// conversations carry their job hint as the title.
 mock.module("../memory/conversation-title-service.js", () => ({
   GENERATING_TITLE: "Generating title...",
+  AUTO_TITLE_DETERMINISTIC: 2,
+  deriveDeterministicTitle: (context: { systemHint?: string }) =>
+    context.systemHint ?? "Untitled Conversation",
   queueGenerateConversationTitle: () => {},
 }));
 
@@ -230,12 +235,12 @@ describe("FilingService", () => {
     );
   });
 
-  test("creates background conversation with generating title placeholder", async () => {
+  test("creates background conversation with the deterministic filing title", async () => {
     const service = createService();
     await service.runOnce();
 
     expect(createdConversations).toHaveLength(1);
-    expect(createdConversations[0].title).toBe("Generating title...");
+    expect(createdConversations[0].title).toBe("Knowledge base filing");
     expect(createdConversations[0].conversationType).toBe("background");
     // Confirms FilingService routes through runBackgroundJob:
     //   source="filing" + runner-default groupId="system:background".

package/src/__tests__/guardian-action-store.test.ts

@@ -17,13 +17,8 @@ import {
   cancelGuardianActionRequest,
   createGuardianActionDelivery,
   createGuardianActionRequest,
-  expireGuardianActionRequest,
   getDeliveriesByRequestId,
-  getExpiredDeliveriesByConversation,
-  getFollowupDeliveriesByConversation,
   getGuardianActionRequest,
-  getPendingDeliveriesByConversation,
-  startFollowupFromExpiredRequest,
   updateDeliveryStatus,
 } from "../memory/guardian-action-store.js";
 import { conversations } from "../memory/schema.js";
@@ -58,168 +53,6 @@ describe("guardian-action-store", () => {
     resetTables();
   });
 
-  // ── Helper to create a pending request+delivery targeting a conversation ──
-  function createPendingRequestWithDelivery(
-    convId: string,
-    deliveryConvId: string,
-  ) {
-    ensureConversation(convId);
-    const session = createCallSession({
-      conversationId: convId,
-      provider: "twilio",
-      fromNumber: "+15550001111",
-      toNumber: "+15550002222",
-    });
-    const pq = createPendingQuestion(session.id, `Question for ${convId}`);
-    const request = createGuardianActionRequest({
-      kind: "ask_guardian",
-      sourceChannel: "phone",
-      sourceConversationId: convId,
-      callSessionId: session.id,
-      pendingQuestionId: pq.id,
-      questionText: pq.questionText,
-      expiresAt: Date.now() + 60_000,
-    });
-    const delivery = createGuardianActionDelivery({
-      requestId: request.id,
-      destinationChannel: "vellum",
-      destinationConversationId: deliveryConvId,
-    });
-    updateDeliveryStatus(delivery.id, "sent");
-    return { request, delivery };
-  }
-
-  // ── getPendingDeliveriesByConversation ──────────────────────────────
-
-  test("getPendingDeliveriesByConversation returns all pending deliveries for a conversation", () => {
-    const sharedConvId = "shared-pending-conv";
-    ensureConversation(sharedConvId);
-
-    const { request: req1 } = createPendingRequestWithDelivery(
-      "source-conv-p1",
-      sharedConvId,
-    );
-    const { request: req2 } = createPendingRequestWithDelivery(
-      "source-conv-p2",
-      sharedConvId,
-    );
-
-    const deliveries = getPendingDeliveriesByConversation(sharedConvId);
-    expect(deliveries).toHaveLength(2);
-
-    const requestIds = deliveries.map((d) => d.requestId);
-    expect(requestIds).toContain(req1.id);
-    expect(requestIds).toContain(req2.id);
-  });
-
-  test("getPendingDeliveriesByConversation returns single delivery (fast path preserved)", () => {
-    const convId = "single-pending-conv";
-    ensureConversation(convId);
-
-    const { request } = createPendingRequestWithDelivery(
-      "source-conv-single-p",
-      convId,
-    );
-
-    const deliveries = getPendingDeliveriesByConversation(convId);
-    expect(deliveries).toHaveLength(1);
-    expect(deliveries[0].requestId).toBe(request.id);
-  });
-
-  test("getPendingDeliveriesByConversation returns empty for non-matching conversation", () => {
-    ensureConversation("other-conv");
-    createPendingRequestWithDelivery("source-conv-no-match", "other-conv");
-
-    const deliveries = getPendingDeliveriesByConversation("nonexistent-conv");
-    expect(deliveries).toHaveLength(0);
-  });
-
-  // ── getExpiredDeliveriesByConversation ──────────────────────────────
-
-  test("getExpiredDeliveriesByConversation returns all expired deliveries for a conversation", () => {
-    const sharedConvId = "shared-expired-conv";
-    ensureConversation(sharedConvId);
-
-    const { request: req1 } = createPendingRequestWithDelivery(
-      "source-conv-e1",
-      sharedConvId,
-    );
-    const { request: req2 } = createPendingRequestWithDelivery(
-      "source-conv-e2",
-      sharedConvId,
-    );
-
-    expireGuardianActionRequest(req1.id, "sweep_timeout");
-    expireGuardianActionRequest(req2.id, "sweep_timeout");
-
-    const deliveries = getExpiredDeliveriesByConversation(sharedConvId);
-    expect(deliveries).toHaveLength(2);
-
-    const requestIds = deliveries.map((d) => d.requestId);
-    expect(requestIds).toContain(req1.id);
-    expect(requestIds).toContain(req2.id);
-  });
-
-  test("getExpiredDeliveriesByConversation excludes deliveries with followup already started", () => {
-    const convId = "expired-with-followup-conv";
-    ensureConversation(convId);
-
-    const { request: req1 } = createPendingRequestWithDelivery(
-      "source-conv-ef1",
-      convId,
-    );
-    const { request: req2 } = createPendingRequestWithDelivery(
-      "source-conv-ef2",
-      convId,
-    );
-
-    expireGuardianActionRequest(req1.id, "sweep_timeout");
-    expireGuardianActionRequest(req2.id, "sweep_timeout");
-
-    // Start followup on req1 — only req2 should remain in the expired query
-    startFollowupFromExpiredRequest(req1.id, "late answer");
-
-    const deliveries = getExpiredDeliveriesByConversation(convId);
-    expect(deliveries).toHaveLength(1);
-    expect(deliveries[0].requestId).toBe(req2.id);
-  });
-
-  // ── getFollowupDeliveriesByConversation ─────────────────────────────
-
-  test("getFollowupDeliveriesByConversation returns all awaiting_guardian_choice deliveries", () => {
-    const convId = "shared-followup-conv";
-    ensureConversation(convId);
-
-    const { request: req1 } = createPendingRequestWithDelivery(
-      "source-conv-f1",
-      convId,
-    );
-    const { request: req2 } = createPendingRequestWithDelivery(
-      "source-conv-f2",
-      convId,
-    );
-
-    expireGuardianActionRequest(req1.id, "sweep_timeout");
-    expireGuardianActionRequest(req2.id, "sweep_timeout");
-
-    startFollowupFromExpiredRequest(req1.id, "late answer 1");
-    startFollowupFromExpiredRequest(req2.id, "late answer 2");
-
-    const deliveries = getFollowupDeliveriesByConversation(convId);
-    expect(deliveries).toHaveLength(2);
-
-    const requestIds = deliveries.map((d) => d.requestId);
-    expect(requestIds).toContain(req1.id);
-    expect(requestIds).toContain(req2.id);
-  });
-
-  test("getFollowupDeliveriesByConversation returns empty for non-matching conversation", () => {
-    const deliveries = getFollowupDeliveriesByConversation("nonexistent-conv");
-    expect(deliveries).toHaveLength(0);
-  });
-
-  // ── cancelGuardianActionRequest ─────────────────────────────────────
-
   test("cancelGuardianActionRequest cancels both pending and sent deliveries", () => {
     const conversationId = "conv-guardian-cancel";
     ensureConversation(conversationId);

package/src/__tests__/handlers-skills-memory-v2-reseed.test.ts

@@ -65,7 +65,7 @@ mock.module("../config/loader.js", () => ({
   saveRawConfig: () => {},
   getNestedValue: () => undefined,
   setNestedValue: () => {},
-  _appendQuarantineBulletin: () => {},
+  _writeQuarantineNotice: () => {},
 }));
 
 mock.module("../config/skill-state.js", () => ({

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

@@ -37,7 +37,7 @@ mock.module("../config/loader.js", () => ({
   getNestedValue: () => undefined,
   setNestedValue: () => {},
   API_KEY_PROVIDERS: [],
-  _appendQuarantineBulletin: () => {},
+  _writeQuarantineNotice: () => {},
   invalidateConfigCache: () => {},
 }));
 
@@ -102,6 +102,9 @@ mock.module("../prompts/persona-resolver.js", () => ({
 
 mock.module("../memory/conversation-title-service.js", () => ({
   GENERATING_TITLE: "Generating title...",
+  AUTO_TITLE_DETERMINISTIC: 2,
+  deriveDeterministicTitle: (context: { systemHint?: string }) =>
+    context.systemHint ?? "Untitled Conversation",
   queueGenerateConversationTitle: () => {},
 }));
 

package/src/__tests__/heartbeat-service.test.ts

@@ -250,6 +250,9 @@ mock.module("../notifications/emit-signal.js", () => ({
 // Mock conversation title service
 mock.module("../memory/conversation-title-service.js", () => ({
   GENERATING_TITLE: "Generating title...",
+  AUTO_TITLE_DETERMINISTIC: 2,
+  deriveDeterministicTitle: (context: { systemHint?: string }) =>
+    context.systemHint ?? "Untitled Conversation",
   queueGenerateConversationTitle: () => {},
 }));
 
@@ -497,12 +500,12 @@ describe("HeartbeatService", () => {
     expect(processMessageCalls[0].content).toContain("Check in with yourself");
   });
 
-  test("creates background conversation with generating title placeholder", async () => {
+  test("creates background conversation with the deterministic heartbeat title", async () => {
     const service = createService();
     await service.runOnce();
 
     expect(createdConversations).toHaveLength(1);
-    expect(createdConversations[0].title).toBe("Generating title...");
+    expect(createdConversations[0].title).toBe("Heartbeat");
     expect(createdConversations[0].conversationType).toBe("background");
   });
 

package/src/__tests__/identity-intro-cache.test.ts

@@ -119,19 +119,26 @@ describe("identity intro cache", () => {
 
     setCachedIntro(["Hello!"]);
 
-    const fortyNineHoursAgo = String(Date.now() - 49 * 60 * 60 * 1000);
-    checkpointStore.set("identity:intro:cached_at", fortyNineHoursAgo);
+    const fourHoursAndOneMinuteAgo = String(
+      Date.now() - (4 * 60 + 1) * 60 * 1000,
+    );
+    checkpointStore.set("identity:intro:cached_at", fourHoursAndOneMinuteAgo);
 
     expect(getCachedIntro()).toBeNull();
   });
 
-  test("returns cached greetings when within TTL (47 hours ago)", () => {
+  test("returns cached greetings when within TTL (3 hours 59 minutes ago)", () => {
     workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
 
     setCachedIntro(["Hello!"]);
 
-    const fortySevenHoursAgo = String(Date.now() - 47 * 60 * 60 * 1000);
-    checkpointStore.set("identity:intro:cached_at", fortySevenHoursAgo);
+    const threeHoursAndFiftyNineMinutesAgo = String(
+      Date.now() - (3 * 60 + 59) * 60 * 1000,
+    );
+    checkpointStore.set(
+      "identity:intro:cached_at",
+      threeHoursAndFiftyNineMinutesAgo,
+    );
 
     const cached = getCachedIntro();
     expect(cached).not.toBeNull();

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

@@ -73,13 +73,6 @@ mock.module("../runtime/btw-sidechain.js", () => ({
   }),
 }));
 
-const assistantFeatureFlags: Record<string, boolean> = {};
-
-mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: (key: string) =>
-    assistantFeatureFlags[key] ?? false,
-}));
-
 import {
   handleDetailedHealth,
   handleReadyz,
@@ -206,9 +199,6 @@ beforeEach(() => {
   sidechainCalls.length = 0;
   sidechainText = "";
   sidechainResultPromise = null;
-  for (const key of Object.keys(assistantFeatureFlags)) {
-    delete assistantFeatureFlags[key];
-  }
 });
 
 afterEach(() => {
@@ -576,53 +566,7 @@ describe("identity routes — createdAt selection", () => {
 });
 
 describe("identity routes — intro greetings", () => {
-  test("returns static fallback and does not generate when the dynamic greetings flag is off", async () => {
-    const workspaceDir = getWorkspaceDir();
-    writeFileSync(
-      join(workspaceDir, "IDENTITY.md"),
-      "# Identity\n\n- **Name:** Example Assistant\n",
-      "utf-8",
-    );
-    writeFileSync(
-      join(workspaceDir, "SOUL.md"),
-      "# Soul\n\nNo explicit greetings section here.\n",
-      "utf-8",
-    );
-
-    const route = ROUTES.find(
-      (candidate) => candidate.operationId === "identity_intro",
-    );
-    expect(route).toBeDefined();
-
-    const body = route!.handler({}) as {
-      greetings: string[];
-      text: string;
-      source: string;
-      refreshing: boolean;
-    };
-
-    expect(body).toEqual({
-      greetings: [
-        "What are we working on?",
-        "I'm here whenever you need me.",
-        "What's on your mind?",
-        "Ready when you are.",
-      ],
-      text: "What are we working on?",
-      source: "fallback",
-      refreshing: false,
-    });
-
-    await Promise.resolve();
-    await Promise.resolve();
-
-    expect(getConfiguredProviderCalls).toEqual([]);
-    expect(sidechainCalls).toEqual([]);
-  });
-
   test("returns fallback immediately, generates personalized greetings in the background, then reuses the cache", async () => {
-    assistantFeatureFlags["empty-state-dynamic-greetings"] = true;
-
     const workspaceDir = getWorkspaceDir();
     writeFileSync(
       join(workspaceDir, "IDENTITY.md"),
@@ -655,7 +599,9 @@ describe("identity routes — intro greetings", () => {
     );
     expect(route).toBeDefined();
 
-    const body = route!.handler({}) as {
+    const body = route!.handler({
+      queryParams: { localHour: "8", localMinute: "15" },
+    }) as {
       greetings: string[];
       text: string;
       source: string;
@@ -683,6 +629,14 @@ describe("identity routes — intro greetings", () => {
     expect(sidechainCalls).toHaveLength(1);
     expect(sidechainCalls[0]?.callSite).toBe("emptyStateGreeting");
     expect(sidechainCalls[0]?.tools).toEqual([]);
+    expect(sidechainCalls[0]?.content).toContain("Generate 5 short");
+    expect(sidechainCalls[0]?.content).not.toContain("Current time of day:");
+    expect(sidechainCalls[0]?.content).toContain(
+      "do not mention the current time",
+    );
+    expect(sidechainCalls[0]?.content).toMatch(
+      /Current user-local time for subtle tone only: morning \(08:15\)\.$/,
+    );
     expect(sidechainCalls[0]?.content).toContain("JSON array");
     expect(sidechainCalls[0]?.systemPrompt).toContain(
       "Identity sentinel: chartreuse compass.",
@@ -695,6 +649,9 @@ describe("identity routes — intro greetings", () => {
         "Charting the next useful thing?",
         "I brought the compass. Where to?",
         "Ready to make this lighter.",
+        "Morning momentum?",
+        "Five options, one good start.",
+        "A useful next step?",
       ]),
       hadTextDeltas: false,
       response: { content: [] },
@@ -718,6 +675,8 @@ describe("identity routes — intro greetings", () => {
         "Charting the next useful thing?",
         "I brought the compass. Where to?",
         "Ready to make this lighter.",
+        "Five options, one good start.",
+        "A useful next step?",
       ],
       text: "Charting the next useful thing?",
       source: "cache",

package/src/__tests__/injector-chain.test.ts

@@ -5,9 +5,10 @@
  *
  * 1. The default injectors ({@link defaultInjectors}) are listed in the
  *    documented order (disk-pressure-warning → workspace-context →
- *    background-turn → unified-turn-context → pkb-context → pkb-reminder →
- *    memory-v2-static → now-md → active-documents → document-comments →
- *    subagent-status → slack-messages → thread-focus).
+ *    background-turn → unified-turn-context → config-quarantine-notice →
+ *    pkb-context → pkb-reminder → memory-v2-static → now-md →
+ *    active-documents → document-comments → subagent-status →
+ *    slack-messages → thread-focus).
  * 2. The assembled {@link injectorChain} sorts the defaults together with the
  *    memory-v3 injector by ascending `order`, so memory-v3 (order 1000) lands
  *    last.
@@ -298,6 +299,7 @@ describe("injector chain", () => {
       "workspace-context",
       "background-turn",
       "unified-turn-context",
+      "config-quarantine-notice",
       "pkb-context",
       "pkb-reminder",
       "memory-v2-static",
@@ -324,6 +326,9 @@ describe("injector chain", () => {
     expect(byName.get("unified-turn-context")).toBe(
       DEFAULT_INJECTOR_ORDER.unifiedTurnContext,
     );
+    expect(byName.get("config-quarantine-notice")).toBe(
+      DEFAULT_INJECTOR_ORDER.configQuarantineNotice,
+    );
     expect(byName.get("pkb-context")).toBe(DEFAULT_INJECTOR_ORDER.pkbContext);
     expect(byName.get("pkb-reminder")).toBe(DEFAULT_INJECTOR_ORDER.pkbReminder);
     expect(byName.get("memory-v2-static")).toBe(

package/src/__tests__/injector-config-quarantine-notice.test.ts

@@ -0,0 +1,115 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  DEFAULT_INJECTOR_ORDER,
+  defaultInjectors,
+} from "../plugins/defaults/memory-retrieval/injectors.js";
+import type { Injector, TurnContext } from "../plugins/types.js";
+import { getConfigQuarantineNoticePath } from "../util/platform.js";
+
+function findInjector(name: string): Injector {
+  const injector = defaultInjectors.find(
+    (candidate) => candidate.name === name,
+  );
+  if (!injector) {
+    throw new Error(`injector '${name}' not registered`);
+  }
+  return injector;
+}
+
+function makeContext(overrides: Partial<TurnContext> = {}): TurnContext {
+  return {
+    requestId: "req-test",
+    conversationId: "conv-test",
+    turnIndex: 0,
+    trust: { sourceChannel: "vellum", trustClass: "guardian" },
+    ...overrides,
+  };
+}
+
+const NOTICE_PATH = getConfigQuarantineNoticePath();
+
+function writeNotice(quarantinedAt: string): void {
+  const dir = dirname(NOTICE_PATH);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    NOTICE_PATH,
+    JSON.stringify(
+      {
+        quarantinedAt,
+        quarantinePath: "/ws/config.json.corrupt-x.json",
+        originalPath: "/ws/config.json",
+      },
+      null,
+      2,
+    ),
+    "utf-8",
+  );
+}
+
+function clearNotice(): void {
+  rmSync(NOTICE_PATH, { force: true });
+}
+
+const injector = findInjector("config-quarantine-notice");
+
+describe("config-quarantine-notice injector", () => {
+  beforeEach(() => {
+    clearNotice();
+  });
+
+  afterEach(() => {
+    clearNotice();
+  });
+
+  test("registered at the expected order with prepend-user-tail placement", async () => {
+    expect(injector.order).toBe(DEFAULT_INJECTOR_ORDER.configQuarantineNotice);
+    writeNotice(new Date().toISOString());
+    const block = await injector.produce(makeContext());
+    expect(block?.placement).toBe("prepend-user-tail");
+  });
+
+  test("returns null when no sentinel is present", async () => {
+    const block = await injector.produce(makeContext());
+    expect(block).toBeNull();
+  });
+
+  test("injects a config-reset block when the sentinel is present and fresh", async () => {
+    writeNotice(new Date().toISOString());
+
+    const block = await injector.produce(makeContext());
+    expect(block).not.toBeNull();
+    expect(block?.id).toBe("config-quarantine-notice");
+    expect(block?.text).toContain("<config_reset_notice>");
+    expect(block?.text).toContain("</config_reset_notice>");
+    expect(block?.text).toContain("/ws/config.json.corrupt-x.json");
+    // The sentinel is left in place for subsequent turns until it ages out.
+    expect(existsSync(NOTICE_PATH)).toBe(true);
+  });
+
+  test("injects nothing on non-guardian turns even when the sentinel is fresh", async () => {
+    writeNotice(new Date().toISOString());
+
+    for (const trustClass of ["trusted_contact", "unknown"] as const) {
+      const block = await injector.produce(
+        makeContext({ trust: { sourceChannel: "slack", trustClass } }),
+      );
+      expect(block).toBeNull();
+    }
+    // The sentinel is untouched — it remains for guardian turns.
+    expect(existsSync(NOTICE_PATH)).toBe(true);
+  });
+
+  test("deletes the sentinel and injects nothing when it is stale (>7 days)", async () => {
+    const eightDaysAgo = new Date(
+      Date.now() - 8 * 24 * 60 * 60 * 1000,
+    ).toISOString();
+    writeNotice(eightDaysAgo);
+
+    const block = await injector.produce(makeContext());
+    expect(block).toBeNull();
+    expect(existsSync(NOTICE_PATH)).toBe(false);
+  });
+});

package/src/__tests__/llm-catalog-parity.test.ts

@@ -309,6 +309,22 @@ describe("LLM catalog parity: daemon vs client", () => {
     });
   });
 
+  test("MiniMax catalog includes MiniMax M3", () => {
+    const minimax = PROVIDER_CATALOG.find((entry) => entry.id === "minimax");
+    expect(
+      minimax?.models.find((model) => model.id === "MiniMax-M3"),
+    ).toMatchObject({
+      displayName: "MiniMax M3",
+      contextWindowTokens: 1000000,
+      defaultContextWindowTokens: 200000,
+      maxOutputTokens: 512000,
+      longContextMode: "native-model",
+      supportsThinking: true,
+      supportsVision: true,
+      supportsToolUse: true,
+    });
+  });
+
   // -----------------------------------------------------------------------
   // pricing.ts ↔ model-catalog.ts parity
   //

package/src/__tests__/llm-usage-store.test.ts

@@ -1653,6 +1653,17 @@ describe("queryUnreportedUsageEvents", () => {
     expect(events[0].turnIndex).toBe(0);
   });
 
+  test("surfaces llmCallCount on unreported events", () => {
+    insertEventAt(1000, { llmCallCount: 4 });
+    insertEventAt(2000, {});
+
+    const events = queryUnreportedUsageEvents(0, undefined, 100);
+    expect(events).toHaveLength(2);
+    expect(events[0].llmCallCount).toBe(4);
+    // recordUsageEvent defaults llmCallCount to 1 when unset.
+    expect(events[1].llmCallCount).toBe(1);
+  });
+
   test("surfaces raw_usage on unreported events", () => {
     // The telemetry reporter consumes `queryUnreportedUsageEvents` output
     // directly and forwards it to BigQuery. If the SELECT projection