@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

package/src/schedule/schedule-usage-store.ts

@@ -0,0 +1,83 @@
+import { rawAll } from "../memory/raw-query.js";
+import { buildScheduleAttributionSubquery } from "../memory/schedule-attribution-sql.js";
+
+export interface ScheduleUsageSummary {
+  scheduleId: string;
+  runCount: number;
+  totalEstimatedCostUsd: number;
+  eventCount: number;
+}
+
+interface ScheduleUsageSummaryRow {
+  schedule_id: string;
+  run_count: number;
+  total_estimated_cost_usd: number | null;
+  event_count: number | null;
+}
+
+export function getScheduleUsageSummaries({
+  from,
+  to,
+}: {
+  from: number;
+  to: number;
+}): ScheduleUsageSummary[] {
+  const now = Date.now();
+  const scheduleAttribution = buildScheduleAttributionSubquery({
+    eventAlias: "e",
+    now,
+    selectExpression: "schedule_attr_runs.job_id",
+  });
+  const rows = rawAll<ScheduleUsageSummaryRow>(
+    /*sql*/ `
+    WITH run_counts AS (
+      SELECT
+        job_id AS schedule_id,
+        COUNT(*) AS run_count
+      FROM cron_runs
+      WHERE started_at >= ?
+        AND started_at <= ?
+      GROUP BY job_id
+    ),
+    attributed_usage AS (
+      SELECT
+        e.estimated_cost_usd,
+        COALESCE(e.llm_call_count, 1) AS event_count,
+        ${scheduleAttribution.sql} AS schedule_id
+      FROM llm_usage_events e
+      WHERE e.created_at >= ?
+        AND e.created_at <= ?
+    ),
+    usage_totals AS (
+      SELECT
+        schedule_id,
+        COALESCE(SUM(estimated_cost_usd), 0) AS total_estimated_cost_usd,
+        COALESCE(SUM(event_count), 0) AS event_count
+      FROM attributed_usage
+      WHERE schedule_id IS NOT NULL
+      GROUP BY schedule_id
+    )
+    SELECT
+      cron_jobs.id AS schedule_id,
+      COALESCE(run_counts.run_count, 0) AS run_count,
+      COALESCE(usage_totals.total_estimated_cost_usd, 0) AS total_estimated_cost_usd,
+      COALESCE(usage_totals.event_count, 0) AS event_count
+    FROM cron_jobs
+    LEFT JOIN run_counts ON run_counts.schedule_id = cron_jobs.id
+    LEFT JOIN usage_totals ON usage_totals.schedule_id = cron_jobs.id
+    ORDER BY cron_jobs.created_at ASC, cron_jobs.id ASC
+    `,
+    from,
+    to,
+    ...scheduleAttribution.params,
+    from,
+    to,
+  );
+
+  return rows.map((row) => ({
+    scheduleId: row.schedule_id,
+    runCount: row.run_count,
+    totalEstimatedCostUsd: row.total_estimated_cost_usd ?? 0,
+    eventCount: row.event_count ?? 0,
+  }));
+}

package/src/schedule/scheduler.ts

@@ -28,6 +28,7 @@ import {
   type RoutingIntent,
   type ScheduleJob,
   scheduleRetry,
+  setScheduleRunConversationId,
 } from "./schedule-store.js";
 
 const log = getLogger("scheduler");
@@ -442,6 +443,7 @@ export async function runScheduleDueWorkOnce(
         job.syntax === "rrule" &&
         job.expression != null &&
         hasSetConstructs(job.expression);
+      const runId = createScheduleRun(job.id, null);
       let failed = false;
       try {
         log.info(
@@ -472,14 +474,13 @@ export async function runScheduleDueWorkOnce(
           },
         );
 
+        setScheduleRunConversationId(runId, result.conversationId);
         onScheduleConversationCreated?.({
           conversationId: result.conversationId,
           scheduleJobId: job.id,
           title: result.status === "failed" ? `${job.name}: Error` : job.name,
         });
 
-        // Track the schedule run using the task's conversation
-        const runId = createScheduleRun(job.id, result.conversationId);
         if (result.status === "failed") {
           const errorMessage = result.error ?? "Task run failed";
           completeScheduleRun(runId, {
@@ -530,7 +531,7 @@ export async function runScheduleDueWorkOnce(
           scheduleJobId: job.id,
           title: `${job.name}: Error`,
         });
-        const runId = createScheduleRun(job.id, fallbackConversation.id);
+        setScheduleRunConversationId(runId, fallbackConversation.id);
         completeScheduleRun(runId, { status: "error", error: message });
         emitTaskActivityFailed({
           taskId,
@@ -584,6 +585,8 @@ export async function runScheduleDueWorkOnce(
     let ok: boolean;
     let errorMsg: string | undefined;
     const conversationReused = reusedConversationId != null;
+    let runConversationId = reusedConversationId;
+    const runId = createScheduleRun(job.id, reusedConversationId);
 
     if (reusedConversationId) {
       // Reuse path: keep using the injected `processMessage` callback so the
@@ -625,6 +628,8 @@ export async function runScheduleDueWorkOnce(
         scheduleJobId: job.id,
         suppressFailureNotifications: job.quiet === true,
         onConversationCreated: (newConversationId) => {
+          runConversationId = newConversationId;
+          setScheduleRunConversationId(runId, newConversationId);
           onScheduleConversationCreated?.({
             conversationId: newConversationId,
             scheduleJobId: job.id,
@@ -641,12 +646,14 @@ export async function runScheduleDueWorkOnce(
         !result.ok && result.conversationId === ""
           ? `bootstrap-error:${job.id}`
           : result.conversationId;
+      if (runConversationId !== conversationId) {
+        runConversationId = conversationId;
+        setScheduleRunConversationId(runId, conversationId);
+      }
       ok = result.ok;
       errorMsg = result.error?.message;
     }
 
-    const runId = createScheduleRun(job.id, conversationId);
-
     if (ok) {
       completeScheduleRun(runId, { status: "ok" });
       if (isOneShot) completeOneShot(job.id);

package/src/signals/cancel.ts

@@ -11,10 +11,8 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
 import { getIsContainerized } from "../config/env-registry.js";
-import {
-  findConversation,
-  touchConversation,
-} from "../daemon/conversation-store.js";
+import { findConversation } from "../daemon/conversation-registry.js";
+import { touchConversation } from "../daemon/conversation-store.js";
 import { getSubagentManager } from "../subagent/index.js";
 import { createAbortReason } from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";

package/src/skills/catalog-files.ts

@@ -37,7 +37,6 @@ import {
 import { getLogger } from "../util/logger.js";
 import { getCachedCatalogSync, getCatalog } from "./catalog-cache.js";
 import { type CatalogSkill, getRepoSkillsDir } from "./catalog-install.js";
-import { inferCategory } from "./category-inference.js";
 import type { SkillFileProvider } from "./skill-file-provider.js";
 
 const log = getLogger("catalog-files");
@@ -503,11 +502,12 @@ export function catalogSkillToSlim(cs: CatalogSkill): SlimSkillResponse {
     id: cs.id,
     name,
     description: cs.description,
+    icon: cs.icon ?? cs.metadata?.icon,
     emoji: cs.emoji ?? cs.metadata?.emoji,
     kind: "catalog",
     origin: "vellum",
     status: "available",
-    category: inferCategory(name, cs.description),
+    category: cs.metadata?.vellum?.category ?? "system",
   };
 }
 

package/src/skills/catalog-install.ts

@@ -29,17 +29,20 @@ export interface CatalogSkill {
   id: string;
   name: string;
   description: string;
+  icon?: string;
   emoji?: string;
   includes?: string[];
   version?: string;
   updatedAt?: string;
   metadata?: {
+    icon?: string;
     emoji?: string;
     vellum?: {
       "display-name"?: string;
       "activation-hints"?: string[];
       "avoid-when"?: string[];
       "feature-flag"?: string;
+      category?: string;
     };
   };
 }

package/src/skills/categories-cache.ts

@@ -0,0 +1,118 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { parse as parseYaml } from "yaml";
+
+import { getPlatformBaseUrl } from "../config/env.js";
+import { getLogger } from "../util/logger.js";
+import { getRepoSkillsDir } from "./catalog-install.js";
+
+const log = getLogger("categories-cache");
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+
+export interface SkillCategoryDef {
+  slug: string;
+  label: string;
+  description: string;
+  icon: string;
+}
+
+let cachedCategories: SkillCategoryDef[] | null = null;
+let cacheTimestamp = 0;
+
+async function fetchCategories(): Promise<SkillCategoryDef[]> {
+  const platformUrl = getPlatformBaseUrl();
+  const url = `${platformUrl}/v1/skills/categories/`;
+  const response = await fetch(url, {
+    signal: AbortSignal.timeout(10000),
+  });
+
+  if (!response.ok) {
+    throw new Error(
+      `Platform API error ${response.status}: ${response.statusText}`,
+    );
+  }
+
+  const data = (await response.json()) as {
+    categories: SkillCategoryDef[];
+  };
+  if (!Array.isArray(data.categories)) {
+    throw new Error("Platform categories response has invalid categories array");
+  }
+  return data.categories.filter(
+    (c): c is SkillCategoryDef =>
+      !!c && typeof c.slug === "string" && typeof c.label === "string",
+  );
+}
+
+function readLocalCategories(repoSkillsDir: string): SkillCategoryDef[] {
+  try {
+    const raw = readFileSync(
+      join(repoSkillsDir, "skill-categories-catalog.yaml"),
+      "utf-8",
+    );
+    const parsed = parseYaml(raw) as { categories?: SkillCategoryDef[] };
+    if (!Array.isArray(parsed?.categories)) return [];
+    return parsed.categories.filter(
+      (c): c is SkillCategoryDef =>
+        !!c && typeof c.slug === "string" && typeof c.label === "string",
+    );
+  } catch {
+    return [];
+  }
+}
+
+export async function getCategories(): Promise<SkillCategoryDef[]> {
+  if (cachedCategories && Date.now() - cacheTimestamp < CACHE_TTL_MS) {
+    return cachedCategories;
+  }
+
+  const repoSkillsDir = getRepoSkillsDir();
+  const local = repoSkillsDir ? readLocalCategories(repoSkillsDir) : [];
+  let categories: SkillCategoryDef[];
+
+  try {
+    const remote = await fetchCategories();
+    if (local.length > 0) {
+      const localSlugs = new Set(local.map((c) => c.slug));
+      categories = [
+        ...local,
+        ...remote.filter((c) => !localSlugs.has(c.slug)),
+      ];
+    } else {
+      categories = remote;
+    }
+  } catch (err) {
+    if (cachedCategories) {
+      log.warn(
+        { err },
+        "Failed to fetch skill categories, keeping stale cache",
+      );
+      cacheTimestamp = Date.now();
+      return cachedCategories;
+    }
+    if (local.length > 0) {
+      log.warn(
+        { err },
+        "Failed to fetch skill categories, falling back to bundled local catalog",
+      );
+      categories = local;
+    } else {
+      log.warn({ err }, "Failed to fetch skill categories, returning empty");
+      return [];
+    }
+  }
+
+  cachedCategories = categories;
+  cacheTimestamp = Date.now();
+  return categories;
+}
+
+export function getCachedCategoriesSync(): SkillCategoryDef[] {
+  return cachedCategories ?? [];
+}
+
+export function invalidateCategoriesCache(): void {
+  cachedCategories = null;
+  cacheTimestamp = 0;
+}

package/src/skills/clawhub-files.ts

@@ -17,7 +17,6 @@ import type { SlimSkillResponse } from "../daemon/message-types/skills.js";
 import { isTextMimeType as isTextMime } from "../runtime/routes/workspace-utils.js";
 import { getLogger } from "../util/logger.js";
 import type { SkillFileEntry } from "./catalog-files.js";
-import { inferCategory } from "./category-inference.js";
 import {
   clawhubInspect,
   clawhubInspectFile,
@@ -199,7 +198,7 @@ export function createClawhubProvider(): SkillFileProvider {
         kind: "catalog",
         status: "available",
         origin: "clawhub",
-        category: inferCategory(data.skill.displayName, data.skill.summary),
+        category: "integrations",
         slug: data.skill.slug,
         author: data.owner?.handle ?? "",
         stars: data.stats?.stars ?? 0,

package/src/skills/skillssh-files.ts

@@ -24,7 +24,6 @@ import {
   sanitizeRelativePath,
   SKIP_DIRS,
 } from "./catalog-files.js";
-import { inferCategory } from "./category-inference.js";
 import type { SkillFileProvider } from "./skill-file-provider.js";
 import type { GitHubContentsEntry } from "./skillssh-registry.js";
 import {
@@ -384,7 +383,7 @@ export function createSkillsShProvider(): SkillFileProvider {
           kind: "catalog",
           status: "available",
           origin: "skillssh",
-          category: inferCategory(source.skillSlug, ""),
+          category: "integrations",
           slug: skillId,
           sourceRepo: `${source.owner}/${source.repo}`,
           installs: 0,

package/src/subagent/manager.ts

@@ -13,7 +13,11 @@ import { v4 as uuid } from "uuid";
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import { Conversation } from "../daemon/conversation.js";
-import { findConversation } from "../daemon/conversation-store.js";
+import {
+  findConversation,
+  removeSubagentConversation,
+  setSubagentConversation,
+} from "../daemon/conversation-registry.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import { bootstrapConversation } from "../memory/conversation-bootstrap.js";
 import { wrapWithCallSiteRouting } from "../providers/call-site-routing.js";
@@ -334,6 +338,10 @@ export class SubagentManager {
 
     managed.conversation = conversation;
     this.subagents.set(subagentId, managed);
+    // Index the live conversation so the per-conversation injectors (workspace
+    // context, disk-pressure warning) can resolve it by id; subagents are not
+    // in the eviction-managed conversation store.
+    setSubagentConversation(conversationRecord.id, conversation);
     const labelKey = `${config.parentConversationId}:${config.label.toLowerCase().trim()}`;
     if (this.labelIndex.has(labelKey)) {
       log.warn(
@@ -695,7 +703,9 @@ export class SubagentManager {
    */
   private releaseConversation(managed: ManagedSubagent): void {
     if (!managed.conversation) return;
-    managed.conversation.dispose();
+    const conversation = managed.conversation;
+    removeSubagentConversation(conversation.conversationId, conversation);
+    conversation.dispose();
     managed.conversation = null;
     managed.retainedUntil = Date.now() + TERMINAL_RETENTION_MS;
     this.ensureSweepRunning();
@@ -716,16 +726,18 @@ export class SubagentManager {
     if (!managed) return;
 
     if (managed.conversation) {
+      const conversation = managed.conversation;
       if (!TERMINAL_STATUSES.has(managed.state.status)) {
-        managed.conversation.abort(
+        conversation.abort(
           createAbortReason(
             "subagent_aborted",
             "SubagentManager.dispose",
-            managed.conversation.conversationId,
+            conversation.conversationId,
           ),
         );
       }
-      managed.conversation.dispose();
+      removeSubagentConversation(conversation.conversationId, conversation);
+      conversation.dispose();
       managed.conversation = null;
     }
     this.subagents.delete(subagentId);

package/src/telemetry/types.ts

@@ -185,9 +185,37 @@ export interface OnboardingTelemetryEvent extends TelemetryEventBase {
   ab_variant?: string;
 }
 
+/**
+ * Auth-fallback event — aggregated count of requests served via the legacy
+ * loopback auth fallback. One event per (guard, path, failure_kind) per flush
+ * window. Lets the platform see which deployments still rely on the loopback
+ * exemption instead of sending a bearer token.
+ */
+export interface AuthFallbackTelemetryEvent extends TelemetryEventBase {
+  type: "auth_fallback";
+  /** Which auth guard fell back: `"edge"` | `"edge-scoped"` | `"edge-guardian"`. */
+  guard: string;
+  /** Request pathname that fell back. */
+  path: string;
+  /**
+   * Why the bearer-token check did not succeed before the fallback:
+   * `"missing_authorization"` | `"malformed_authorization"` |
+   * `"token_validation_failed"` | `"insufficient_scope"` |
+   * `"non_actor_principal"` | `"guardian_mismatch"`.
+   */
+  failure_kind: string;
+  /** Number of requests that fell back for this key during the window. */
+  count: number;
+  /** Window start (epoch ms) the count was accumulated over. */
+  window_start: number;
+  /** Window end (epoch ms) the count was accumulated over. */
+  window_end: number;
+}
+
 /** Discriminated union of all telemetry event types. */
 export type TelemetryEvent =
   | LlmUsageTelemetryEvent
   | TurnTelemetryEvent
   | LifecycleTelemetryEvent
-  | OnboardingTelemetryEvent;
+  | OnboardingTelemetryEvent
+  | AuthFallbackTelemetryEvent;

package/src/telemetry/usage-telemetry-reporter.test.ts

@@ -94,7 +94,15 @@ mock.module("../version.js", () => ({
 let mockCollectUsageData = true;
 
 mock.module("../config/loader.js", () => ({
-  getConfig: () => ({ collectUsageData: mockCollectUsageData }),
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+    collectUsageData: mockCollectUsageData,
+  }),
 }));
 
 const mockQueryUnreportedLifecycleEvents = mock(
@@ -130,13 +138,24 @@ mock.module("../memory/onboarding-events-store.js", () => ({
   queryUnreportedOnboardingEvents: mockQueryUnreportedOnboardingEvents,
 }));
 
+// The auth-fallback store is intentionally NOT mocked — it has its own
+// DB-backed tests, and Bun's `mock.module` is process-global, so mocking it
+// here would leak into those tests when files share an invocation. We seed the
+// real DB instead so every auth-fallback test stays order-independent.
+
 // ---------------------------------------------------------------------------
 // Production import (after mocks)
 // ---------------------------------------------------------------------------
 
+import { recordAuthFallbackCounts } from "../memory/auth-fallback-events-store.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { authFallbackEvents } from "../memory/schema.js";
 import type { UsageEvent } from "../usage/types.js";
 import { UsageTelemetryReporter } from "./usage-telemetry-reporter.js";
 
+initializeDb();
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -201,6 +220,7 @@ beforeEach(() => {
   mockQueryUnreportedLifecycleEvents.mockReturnValue([]);
   mockQueryUnreportedOnboardingEvents.mockReset();
   mockQueryUnreportedOnboardingEvents.mockReturnValue([]);
+  getDb().delete(authFallbackEvents).run();
   mockPlatformClient = null;
   mockGetPlatformBaseUrl.mockReset();
   mockGetDeviceId.mockReset();
@@ -909,9 +929,9 @@ describe("UsageTelemetryReporter", () => {
     // No HTTP call should have been made
     expect(mockFetch).not.toHaveBeenCalled();
 
-    // All 4 timestamp watermarks should have been advanced (IDs left untouched
+    // All 5 timestamp watermarks should have been advanced (IDs left untouched
     // so the compound-cursor branch stays active)
-    expect(mockSetMemoryCheckpoint).toHaveBeenCalledTimes(4);
+    expect(mockSetMemoryCheckpoint).toHaveBeenCalledTimes(5);
 
     const calls = mockSetMemoryCheckpoint.mock.calls;
     const keys = calls.map((c) => c[0]);
@@ -919,6 +939,7 @@ describe("UsageTelemetryReporter", () => {
     expect(keys).toContain("telemetry:turns:last_reported_at");
     expect(keys).toContain("telemetry:lifecycle:last_reported_at");
     expect(keys).toContain("telemetry:onboarding:last_reported_at");
+    expect(keys).toContain("telemetry:auth_fallback:last_reported_at");
   });
 
   test("events sent normally after re-enabling collectUsageData", async () => {
@@ -1075,4 +1096,92 @@ describe("UsageTelemetryReporter", () => {
     // Envelope still reflects the running binary, not either event.
     expect(body.assistant_version).toBe("1.2.3-test");
   });
+
+  // -------------------------------------------------------------------------
+  // Auth-fallback events
+  // -------------------------------------------------------------------------
+
+  test("auth_fallback events are included in the events array with type discriminator", async () => {
+    mockQueryUnreportedUsageEvents.mockReturnValue([]);
+    recordAuthFallbackCounts(1700000740000, 1700000800000, [
+      {
+        guard: "edge",
+        path: "/v1/messages",
+        failureKind: "missing_authorization",
+        count: 42,
+      },
+    ]);
+    mockFetch.mockImplementation(() =>
+      Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
+    );
+
+    const reporter = new UsageTelemetryReporter();
+    await reporter.flush();
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const body = JSON.parse(
+      (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    expect(body.events.length).toBe(1);
+    expect(body.events[0]).toMatchObject({
+      type: "auth_fallback",
+      guard: "edge",
+      path: "/v1/messages",
+      failure_kind: "missing_authorization",
+      count: 42,
+      window_start: 1700000740000,
+      window_end: 1700000800000,
+      assistant_version: "1.2.3-test",
+    });
+    // recorded_at is the row's createdAt (stamped at record time).
+    expect(typeof body.events[0].recorded_at).toBe("number");
+    expect(typeof body.events[0].daemon_event_id).toBe("string");
+  });
+
+  test("auth_fallback watermark advances to the last reported row on success", async () => {
+    mockQueryUnreportedUsageEvents.mockReturnValue([]);
+    recordAuthFallbackCounts(1700000000000, 1700000001000, [
+      {
+        guard: "edge-scoped",
+        path: "/v1/a",
+        failureKind: "insufficient_scope",
+        count: 1,
+      },
+      {
+        guard: "edge-guardian",
+        path: "/v1/b",
+        failureKind: "guardian_mismatch",
+        count: 3,
+      },
+    ]);
+    mockFetch.mockImplementation(() =>
+      Promise.resolve(new Response('{"accepted":2}', { status: 200 })),
+    );
+
+    // The last row by the reporter's (createdAt, id) cursor order is the one
+    // whose watermark should be persisted after a successful upload.
+    const rows = getDb()
+      .select()
+      .from(authFallbackEvents)
+      .orderBy(authFallbackEvents.createdAt, authFallbackEvents.id)
+      .all();
+    const lastRow = rows[rows.length - 1];
+
+    const reporter = new UsageTelemetryReporter();
+    await reporter.flush();
+
+    const watermarkCalls = mockSetMemoryCheckpoint.mock.calls.filter(
+      (c) => c[0] === "telemetry:auth_fallback:last_reported_at",
+    );
+    expect(watermarkCalls.length).toBeGreaterThanOrEqual(1);
+    expect(watermarkCalls[watermarkCalls.length - 1][1]).toBe(
+      String(lastRow.createdAt),
+    );
+
+    const idCalls = mockSetMemoryCheckpoint.mock.calls.filter(
+      (c) => c[0] === "telemetry:auth_fallback:last_reported_id",
+    );
+    expect(idCalls.length).toBeGreaterThanOrEqual(1);
+    expect(idCalls[idCalls.length - 1][1]).toBe(lastRow.id);
+  });
 });