@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

package/src/__tests__/llm-resolver.test.ts

@@ -556,6 +556,29 @@ describe("resolveCallSiteConfig", () => {
     expect(resolved.effort).toBe("low");
   });
 
+  test("empty-state greeting defaults to the balanced profile", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        balanced: {
+          model: "claude-sonnet-4-7",
+          effort: "medium",
+        },
+        "cost-optimized": {
+          model: "claude-haiku-4-5-20251001",
+          effort: "low",
+        },
+      },
+    });
+
+    expect(resolveDefaultProfileKey("emptyStateGreeting", llm)).toBe(
+      "balanced",
+    );
+    const resolved = resolveCallSiteConfig("emptyStateGreeting", llm);
+    expect(resolved.model).toBe("claude-sonnet-4-7");
+    expect(resolved.effort).toBe("medium");
+  });
+
   test("explicit callSites config overrides CALL_SITE_DEFAULTS", () => {
     const llm = LLMSchema.parse({
       default: fullDefault,
@@ -1226,50 +1249,3 @@ describe("resolveDefaultProfileKey", () => {
     expect(resolveDefaultProfileKey("mainAgent", llm)).toBe("balanced");
   });
 });
-
-describe("memory v3 call sites resolve through the standard resolver", () => {
-  const llm = LLMSchema.parse({
-    default: fullDefault,
-    profiles: {
-      balanced: { provider: "anthropic", model: "claude-sonnet-4-7" },
-      "cost-optimized": {
-        provider: "anthropic",
-        model: "claude-haiku-4-5-20251001",
-      },
-    },
-  });
-
-  test("memoryV3Filter and memoryV3Descent resolve to the cost-optimized profile", () => {
-    expect(resolveDefaultProfileKey("memoryV3Filter", llm)).toBe(
-      "cost-optimized",
-    );
-    expect(resolveDefaultProfileKey("memoryV3Descent", llm)).toBe(
-      "cost-optimized",
-    );
-    expect(resolveCallSiteConfig("memoryV3Filter", llm).model).toBe(
-      "claude-haiku-4-5-20251001",
-    );
-    expect(resolveCallSiteConfig("memoryV3Descent", llm).model).toBe(
-      "claude-haiku-4-5-20251001",
-    );
-  });
-
-  test("memoryV3Gate resolves to the balanced (capable) profile", () => {
-    expect(resolveDefaultProfileKey("memoryV3Gate", llm)).toBe("balanced");
-    expect(resolveCallSiteConfig("memoryV3Gate", llm).model).toBe(
-      "claude-sonnet-4-7",
-    );
-  });
-
-  test("v3 call sites are addressable as call-site override keys", () => {
-    const overridden = LLMSchema.parse({
-      default: fullDefault,
-      callSites: {
-        memoryV3Gate: { model: "claude-opus-4-7" },
-      },
-    });
-    expect(resolveCallSiteConfig("memoryV3Gate", overridden).model).toBe(
-      "claude-opus-4-7",
-    );
-  });
-});

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

@@ -6,7 +6,7 @@ mock.module("../util/logger.js", () => ({
   getLogger: () => makeMockLogger(),
 }));
 
-import { getDb } from "../memory/db-connection.js";
+import { getDb, getSqlite } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import {
   getUsageDayBuckets,
@@ -456,6 +456,228 @@ describe("getUsageTotals", () => {
   });
 });
 
+describe("usage aggregation schedule filters", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run(`DELETE FROM llm_usage_events`);
+    db.run(`DELETE FROM cron_runs`);
+    db.run(`DELETE FROM cron_jobs`);
+  });
+
+  function insertScheduleJob(id: string, name: string): void {
+    const now = Date.UTC(2026, 0, 1);
+    getSqlite().run(
+      `INSERT INTO cron_jobs (
+        id,
+        name,
+        cron_expression,
+        message,
+        next_run_at,
+        created_by,
+        created_at,
+        updated_at
+      ) VALUES (?, ?, '* * * * *', 'Example scheduled task', ?, 'user', ?, ?)`,
+      [id, name, now, now, now],
+    );
+  }
+
+  function insertScheduleRun({
+    id,
+    scheduleId,
+    conversationId,
+    startedAt,
+    finishedAt,
+  }: {
+    id: string;
+    scheduleId: string;
+    conversationId: string;
+    startedAt: number;
+    finishedAt: number | null;
+  }): void {
+    getSqlite().run(
+      `INSERT INTO cron_runs (
+        id,
+        job_id,
+        status,
+        started_at,
+        finished_at,
+        conversation_id,
+        created_at
+      ) VALUES (?, ?, 'ok', ?, ?, ?, ?)`,
+      [id, scheduleId, startedAt, finishedAt, conversationId, startedAt],
+    );
+  }
+
+  function seedScheduleUsage(): void {
+    insertScheduleJob("schedule-a", "Morning summary");
+    insertScheduleJob("schedule-b", "Nightly sync");
+    insertScheduleRun({
+      id: "run-a-1",
+      scheduleId: "schedule-a",
+      conversationId: "conv-reused",
+      startedAt: 1_000,
+      finishedAt: 2_000,
+    });
+    insertScheduleRun({
+      id: "run-b-1",
+      scheduleId: "schedule-b",
+      conversationId: "conv-reused",
+      startedAt: 3_000,
+      finishedAt: 3_500,
+    });
+
+    insertEventAt(
+      900,
+      { conversationId: "conv-reused", inputTokens: 90 },
+      { estimatedCostUsd: 0.09, pricingStatus: "priced" },
+    );
+    insertEventAt(
+      1_000,
+      {
+        conversationId: "conv-reused",
+        callSite: "mainAgent",
+        inputTokens: 100,
+      },
+      { estimatedCostUsd: 0.1, pricingStatus: "priced" },
+    );
+    insertEventAt(
+      1_500,
+      {
+        conversationId: "conv-reused",
+        callSite: "mainAgent",
+        inputTokens: 200,
+      },
+      { estimatedCostUsd: 0.2, pricingStatus: "priced" },
+    );
+    insertEventAt(
+      2_000,
+      {
+        conversationId: "conv-reused",
+        callSite: "mainAgent",
+        inputTokens: 300,
+      },
+      { estimatedCostUsd: 0.3, pricingStatus: "priced" },
+    );
+    insertEventAt(
+      2_500,
+      { conversationId: "conv-reused", inputTokens: 400 },
+      { estimatedCostUsd: 0.4, pricingStatus: "priced" },
+    );
+    insertEventAt(
+      3_200,
+      {
+        conversationId: "conv-reused",
+        provider: "openai",
+        inputTokens: 500,
+      },
+      { estimatedCostUsd: 0.5, pricingStatus: "priced" },
+    );
+    insertEventAt(
+      1_500,
+      { conversationId: "conv-other", inputTokens: 800 },
+      { estimatedCostUsd: 0.8, pricingStatus: "priced" },
+    );
+  }
+
+  test("filters totals, buckets, breakdowns, and series by cron run windows", () => {
+    seedScheduleUsage();
+    const range = { from: 0, to: 4_000 };
+    const filter = { scheduleId: "schedule-a" };
+
+    const totals = getUsageTotals(range, filter);
+    expect(totals.eventCount).toBe(3);
+    expect(totals.totalInputTokens).toBe(600);
+    expect(totals.totalEstimatedCostUsd).toBeCloseTo(0.6);
+
+    const dailyBuckets = getUsageDayBuckets(range, "UTC", {}, filter);
+    expect(dailyBuckets).toHaveLength(1);
+    expect(dailyBuckets[0].totalInputTokens).toBe(600);
+    expect(dailyBuckets[0].eventCount).toBe(3);
+
+    const hourlyBuckets = getUsageHourBuckets(range, "UTC", {}, filter);
+    expect(hourlyBuckets).toHaveLength(1);
+    expect(hourlyBuckets[0].totalInputTokens).toBe(600);
+    expect(hourlyBuckets[0].eventCount).toBe(3);
+
+    const breakdown = getUsageGroupBreakdown(range, "provider", filter);
+    expect(breakdown).toHaveLength(1);
+    expect(breakdown[0].group).toBe("anthropic");
+    expect(breakdown[0].totalInputTokens).toBe(600);
+    expect(breakdown[0].eventCount).toBe(3);
+
+    const series = getUsageGroupedSeries(
+      range,
+      "call_site",
+      "daily",
+      "UTC",
+      {},
+      filter,
+    );
+    expect(series).toHaveLength(1);
+    expect(series[0].totalInputTokens).toBe(600);
+    expect(series[0].groups["null:call_site"]).toBeUndefined();
+    expect(series[0].groups["null:schedule"]).toBeUndefined();
+    expect(series[0].groups["value:mainAgent"]).toMatchObject({
+      group: "Main Agent",
+      totalInputTokens: 600,
+      eventCount: 3,
+    });
+  });
+
+  test("groups schedule-attributed usage by schedule id with schedule names", () => {
+    seedScheduleUsage();
+    const range = { from: 0, to: 4_000 };
+
+    const breakdown = getUsageGroupBreakdown(range, "schedule");
+    const scheduleA = breakdown.find((row) => row.groupKey === "schedule-a");
+    const scheduleB = breakdown.find((row) => row.groupKey === "schedule-b");
+    const other = breakdown.find((row) => row.groupKey === null);
+
+    expect(scheduleA).toMatchObject({
+      group: "Morning summary",
+      groupId: "schedule-a",
+      groupKey: "schedule-a",
+      totalInputTokens: 600,
+      eventCount: 3,
+    });
+    expect(scheduleB).toMatchObject({
+      group: "Nightly sync",
+      groupId: "schedule-b",
+      groupKey: "schedule-b",
+      totalInputTokens: 500,
+      eventCount: 1,
+    });
+    expect(other).toMatchObject({
+      group: "Other",
+      groupId: null,
+      groupKey: null,
+      totalInputTokens: 1_290,
+      eventCount: 3,
+    });
+
+    const series = getUsageGroupedSeries(range, "schedule", "daily", "UTC", {});
+    expect(series).toHaveLength(1);
+    expect(series[0].groups["value:schedule-a"]).toMatchObject({
+      group: "Morning summary",
+      groupKey: "schedule-a",
+      totalInputTokens: 600,
+      eventCount: 3,
+    });
+    expect(series[0].groups["value:schedule-b"]).toMatchObject({
+      group: "Nightly sync",
+      groupKey: "schedule-b",
+      totalInputTokens: 500,
+      eventCount: 1,
+    });
+    expect(series[0].groups["null:schedule"]).toMatchObject({
+      group: "Other",
+      groupKey: null,
+      totalInputTokens: 1_290,
+      eventCount: 3,
+    });
+  });
+});
+
 describe("getUsageDayBuckets", () => {
   beforeEach(() => {
     const db = getDb();
@@ -1458,3 +1680,48 @@ describe("queryUnreportedUsageEvents", () => {
     expect(events[0].rawUsage).toEqual(rawUsage);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Record-time assistantVersion stamping (May 2026 telemetry honesty fix)
+//
+// Events buffered while the assistant is offline must remember the binary
+// that was running when they were recorded, not the one that finally
+// uploads them. recordUsageEvent stamps APP_VERSION at insert time and the
+// query must return it so the reporter can put it on the wire.
+// ---------------------------------------------------------------------------
+
+describe("recordUsageEvent — assistantVersion stamping", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run(`DELETE FROM llm_usage_events`);
+  });
+
+  test("stamps APP_VERSION on the returned event", async () => {
+    const { APP_VERSION } = await import("../version.js");
+    const event = recordUsageEvent(makeInput(), pricedResult);
+    expect(event.assistantVersion).toBe(APP_VERSION);
+  });
+
+  test("persists assistantVersion and queryUnreportedUsageEvents returns it", async () => {
+    const { APP_VERSION } = await import("../version.js");
+    insertEventAt(1000);
+    const [event] = queryUnreportedUsageEvents(0, undefined, 100);
+    expect(event).toBeDefined();
+    expect(event.assistantVersion).toBe(APP_VERSION);
+  });
+
+  test("legacy rows (null assistant_version column) round-trip as null", () => {
+    // Simulate a row that was persisted before migration 267 ran by
+    // inserting one through recordUsageEvent and then nulling the
+    // column out. This mirrors what production rows look like before
+    // the migration backfills `null`s; the reporter must accept them
+    // and let the platform fall back to the envelope's version.
+    insertEventAt(1000);
+    const db = getDb();
+    db.run(`UPDATE llm_usage_events SET assistant_version = NULL`);
+
+    const [event] = queryUnreportedUsageEvents(0, undefined, 100);
+    expect(event).toBeDefined();
+    expect(event.assistantVersion).toBeNull();
+  });
+});

package/src/__tests__/log-export-routes.test.ts

@@ -1,6 +1,7 @@
 import { spawnSync } from "node:child_process";
 import {
   existsSync,
+  mkdirSync,
   mkdtempSync,
   readFileSync,
   rmSync,
@@ -26,6 +27,7 @@ import { initializeDb } from "../memory/db-init.js";
 import { llmUsageEvents } from "../memory/schema.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { ROUTES } from "../runtime/routes/log-export-routes.js";
+import { getLogsDir } from "../util/platform.js";
 
 initializeDb();
 
@@ -136,6 +138,63 @@ describe("POST /v1/export - connected clients", () => {
   });
 });
 
+describe("POST /v1/export - conversation-scoped daemon logs", () => {
+  test("retains the full daily assistant log even when lines are not tagged with the conversationId", async () => {
+    /**
+     * Tests that a conversation-scoped export keeps the full daily assistant
+     * log so agent-loop failures logged without the conversationId stay
+     * visible, while still emitting the conversation-filtered index.
+     */
+
+    // GIVEN a daily assistant log with a line that mentions the conversation
+    // AND an agent-loop failure line that does NOT — the kind that
+    // conversationId grepping would drop
+    const conversationId = "conv-export-log-retention";
+    const today = new Date().toISOString().slice(0, 10);
+    const logsDir = getLogsDir();
+    mkdirSync(logsDir, { recursive: true });
+    const logFileName = `assistant-${today}.log`;
+    const logPath = join(logsDir, logFileName);
+    const taggedLine = `[agent] processing turn for ${conversationId}`;
+    const untaggedErrorLine =
+      "[agent] ERROR agent loop failed: stream aborted before first token";
+    writeFileSync(logPath, `${taggedLine}\n${untaggedErrorLine}\n`, "utf-8");
+
+    try {
+      // WHEN we run a conversation-scoped export
+      const result = await exportRoute.handler({ body: { conversationId } });
+
+      // THEN the archive is produced
+      expect(result).toBeInstanceOf(Uint8Array);
+
+      const dir = await extractArchive(result as Uint8Array);
+      try {
+        // AND the full daily log is retained, including the untagged failure
+        const exportedLogPath = join(dir, "daemon-logs", logFileName);
+        expect(existsSync(exportedLogPath)).toBe(true);
+        const exportedLog = readFileSync(exportedLogPath, "utf-8");
+        expect(exportedLog).toContain(untaggedErrorLine);
+        expect(exportedLog).toContain(taggedLine);
+
+        // AND the conversation-filtered slice still exists as a quick index
+        const filteredPath = join(
+          dir,
+          "daemon-logs",
+          "conversation-filtered.jsonl",
+        );
+        expect(existsSync(filteredPath)).toBe(true);
+        const filtered = readFileSync(filteredPath, "utf-8");
+        expect(filtered).toContain(taggedLine);
+        expect(filtered).not.toContain(untaggedErrorLine);
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    } finally {
+      rmSync(logPath, { force: true });
+    }
+  });
+});
+
 describe("POST /v1/export - LLM usage events", () => {
   test("full export includes usage attribution columns", async () => {
     const db = getDb();

package/src/__tests__/managed-skill-lifecycle.test.ts

@@ -87,7 +87,7 @@ import {
   seedV2SkillEntries,
 } from "../memory/v2/skill-store.js";
 import { executeDeleteManagedSkill } from "../tools/skills/delete-managed.js";
-import { SkillLoadTool } from "../tools/skills/load.js";
+import { skillLoadTool } from "../tools/skills/load.js";
 import { executeScaffoldManagedSkill } from "../tools/skills/scaffold-managed.js";
 import type { ToolContext } from "../tools/types.js";
 
@@ -136,9 +136,6 @@ Run the custom lifecycle verification procedure.
     expect(catalogSkill!.source).toBe("managed");
     expect(catalogSkill!.displayName).toBe("E2E Custom Skill");
 
-    const skillLoadTool = new (SkillLoadTool as any)() as InstanceType<
-      typeof SkillLoadTool
-    >;
     const loadResult = await skillLoadTool.execute(
       { skill: skillId },
       makeContext(),
@@ -280,10 +277,6 @@ Run the custom lifecycle verification procedure.
   test("scaffold → skill_load chain: literal tool execution", async () => {
     const ctx = makeContext();
 
-    const skillLoadTool = new (SkillLoadTool as any)() as InstanceType<
-      typeof SkillLoadTool
-    >;
-
     // Step 1: Scaffold a skill directly
     const scaffoldResult = await executeScaffoldManagedSkill(
       {

package/src/__tests__/mcp-auth-routes.test.ts

@@ -24,19 +24,24 @@ mock.module("../mcp/mcp-auth-state.js", () => ({
   getMcpAuthState: mockGetMcpAuthState,
 }));
 
-mock.module("../config/loader.js", () => ({
-  loadRawConfig: () => ({
-    mcp: {
-      servers: {
-        "my-server": {
-          transport: { type: "sse", url: "https://mcp.example.com" },
-          enabled: true,
-          defaultRiskLevel: "high",
-        },
+const mockConfig = {
+  mcp: {
+    servers: {
+      "my-server": {
+        transport: { type: "sse", url: "https://mcp.example.com" },
+        enabled: true,
+        defaultRiskLevel: "high",
       },
     },
-  }),
+  },
+};
+mock.module("../config/loader.js", () => ({
+  loadRawConfig: () => mockConfig,
   saveRawConfig: () => {},
+  // route-policy → config/env transitively imports `getConfig`; stub it
+  // here so the mock surface matches what consumers expect.
+  getConfig: () => mockConfig,
+  getConfigReadOnly: () => mockConfig,
 }));
 
 mock.module("../util/logger.js", () => ({

package/src/__tests__/mcp-health-check.test.ts

@@ -18,23 +18,28 @@ mock.module("../mcp/client.js", () => ({
   },
 }));
 
-mock.module("../config/loader.js", () => ({
-  loadRawConfig: () => ({
-    mcp: {
-      servers: {
-        test: {
-          transport: {
-            type: "streamable-http",
-            url: "https://example.com/mcp",
-          },
-          enabled: true,
-          defaultRiskLevel: "high",
-          maxTools: 20,
+const mockConfig = {
+  mcp: {
+    servers: {
+      test: {
+        transport: {
+          type: "streamable-http",
+          url: "https://example.com/mcp",
         },
+        enabled: true,
+        defaultRiskLevel: "high",
+        maxTools: 20,
       },
     },
-  }),
+  },
+};
+mock.module("../config/loader.js", () => ({
+  loadRawConfig: () => mockConfig,
   saveRawConfig: () => {},
+  // route-policy → config/env transitively imports `getConfig`; stub it
+  // here so the mock surface matches what consumers expect.
+  getConfig: () => mockConfig,
+  getConfigReadOnly: () => mockConfig,
 }));
 
 mock.module("../daemon/mcp-reload-service.js", () => ({