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

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

@@ -85,6 +85,7 @@ const stubConfig: {
     activeHoursStart: number | null;
     activeHoursEnd: number | null;
     maxConsecutiveRuns: number | null;
+    maxDailyRuns: number | null;
     disposition: string;
   };
 } = {
@@ -94,6 +95,7 @@ const stubConfig: {
     activeHoursStart: null,
     activeHoursEnd: null,
     maxConsecutiveRuns: null,
+    maxDailyRuns: null,
     disposition: "Default disposition text.",
   },
 };
@@ -195,6 +197,7 @@ mock.module("../heartbeat-run-store.js", () => ({
   markStaleRunsAsMissed: () => 0,
   markStaleRunningAsError: () => 0,
   countCompletedHeartbeatRuns: () => 10,
+  countCompletedRunsToday: () => 0,
   countRecentConsecutiveRuns: () => 0,
 }));
 

package/src/heartbeat/heartbeat-run-store.ts

@@ -24,7 +24,8 @@ export type HeartbeatSkipReason =
   | "outside_active_hours"
   | "overlap"
   | "pre_first_user_message"
-  | "max_consecutive_runs";
+  | "max_consecutive_runs"
+  | "max_daily_runs";
 
 export interface HeartbeatRunRecord {
   id: string;
@@ -217,6 +218,27 @@ export function countCompletedHeartbeatRuns(): number {
   return row?.count ?? 0;
 }
 
+/**
+ * Count heartbeat runs that completed with status `ok` today (local midnight).
+ */
+export function countCompletedRunsToday(): number {
+  const db = getDb();
+  const now = new Date();
+  const startOfDay = new Date(
+    now.getFullYear(),
+    now.getMonth(),
+    now.getDate(),
+  ).getTime();
+  const row = db
+    .select({ count: sql<number>`count(*)` })
+    .from(heartbeatRuns)
+    .where(
+      sql`${heartbeatRuns.status} = 'ok' AND ${heartbeatRuns.scheduledFor} >= ${startOfDay}`,
+    )
+    .get();
+  return row?.count ?? 0;
+}
+
 /**
  * Count the most recent consecutive heartbeat runs with status `ok`,
  * walking backwards from newest. Stops at the first non-`ok` status

package/src/heartbeat/heartbeat-service.ts

@@ -25,6 +25,7 @@ import { stripCommentLines } from "../util/strip-comment-lines.js";
 import {
   completeHeartbeatRun,
   countCompletedHeartbeatRuns,
+  countCompletedRunsToday,
   countRecentConsecutiveRuns,
   insertPendingHeartbeatRun,
   markStaleRunningAsError,
@@ -187,6 +188,13 @@ export class HeartbeatService {
     );
   }
 
+  /** Whether the daily run cap has been reached. */
+  get isDailyCapReached(): boolean {
+    const config = getConfig().heartbeat;
+    if (config.maxDailyRuns == null) return false;
+    return countCompletedRunsToday() >= config.maxDailyRuns;
+  }
+
   async runManagedWakeIfDue(
     options: ManagedWakeHeartbeatRunOptions = {},
   ): Promise<ManagedWakeHeartbeatRunResult> {
@@ -551,6 +559,24 @@ export class HeartbeatService {
       return false;
     }
 
+    // Daily run cap — stop burning tokens when the daily budget is exhausted.
+    // Force runs bypass the cap.
+    if (
+      !force &&
+      config.maxDailyRuns != null &&
+      countCompletedRunsToday() >= config.maxDailyRuns
+    ) {
+      log.debug(
+        { maxDailyRuns: config.maxDailyRuns },
+        "Daily run cap reached, skipping",
+      );
+      if (runId) skipHeartbeatRun(runId, "max_daily_runs");
+      if (!this.cronMode) {
+        this.scheduleNextRun(config.intervalMs);
+      }
+      return false;
+    }
+
     // Overlap prevention
     if (this.activeRun) {
       log.debug("Previous heartbeat run still active, skipping");

package/src/home/home-greeting-cache.ts

@@ -10,11 +10,15 @@
  * Storage uses the existing `memory_checkpoints` table (simple key-value store).
  */
 
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+
 import {
   getMemoryCheckpoint,
   setMemoryCheckpoint,
 } from "../memory/checkpoints.js";
-import { computeIdentityContentHash } from "../runtime/routes/identity-intro-cache.js";
+import { resolveGuardianPersona } from "../prompts/persona-resolver.js";
+import { getWorkspacePromptPath } from "../util/platform.js";
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -26,6 +30,25 @@ const CHECKPOINT_KEY_TEXT = "home:greeting:text";
 const CHECKPOINT_KEY_HASH = "home:greeting:content_hash";
 const CHECKPOINT_KEY_TIMESTAMP = "home:greeting:cached_at";
 
+const IDENTITY_FILES = ["IDENTITY.md", "SOUL.md"] as const;
+
+function readWorkspaceFile(name: string): string {
+  try {
+    const path = getWorkspacePromptPath(name);
+    if (!existsSync(path)) return "";
+    return readFileSync(path, "utf-8");
+  } catch {
+    return "";
+  }
+}
+
+function computeIdentityContentHash(): string {
+  const staticFiles = IDENTITY_FILES.map(readWorkspaceFile).join("\n---\n");
+  const guardianPersona = resolveGuardianPersona() ?? "";
+  const combined = staticFiles + "\n---\n" + guardianPersona;
+  return createHash("sha256").update(combined).digest("hex");
+}
+
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------

package/src/ipc/__tests__/browser-ipc.test.ts

@@ -55,7 +55,7 @@ mock.module("../../browser/operations.js", () => ({
   },
 }));
 
-mock.module("../../daemon/conversation-store.js", () => ({
+mock.module("../../daemon/conversation-registry.js", () => ({
   findConversation: (conversationId: string) => {
     mockFindConversationCalls.push(conversationId);
     return mockConversation ?? undefined;

package/src/ipc/__tests__/ui-request-route.test.ts

@@ -32,9 +32,9 @@ let mockSurfaceResult: InteractiveUiResult = {
 let mockSurfaceThrows: Error | null = null;
 
 // Re-export the real module and override only findConversation.
-const realStore = await import("../../daemon/conversation-store.js");
-mock.module("../../daemon/conversation-store.js", () => ({
-  ...realStore,
+const realRegistry = await import("../../daemon/conversation-registry.js");
+mock.module("../../daemon/conversation-registry.js", () => ({
+  ...realRegistry,
   findConversation: (_conversationId: string) => mockConversation ?? undefined,
 }));
 

package/src/ipc/gateway-client.test.ts

@@ -91,7 +91,7 @@ describe("ipcGetFeatureFlags", () => {
     expect(flags).toEqual({ "flag-a": true, "flag-b": false });
   });
 
-  test("filters non-boolean values from response", async () => {
+  test("accepts boolean and string values, filters other types from response", async () => {
     mockGatewayIpc(null, {
       results: {
         get_feature_flags: {
@@ -104,7 +104,7 @@ describe("ipcGetFeatureFlags", () => {
     });
 
     const flags = await ipcGetFeatureFlags();
-    expect(flags).toEqual({ valid: true });
+    expect(flags).toEqual({ valid: true, string: "yes" });
   });
 
   test("returns empty record when IPC returns undefined", async () => {

package/src/ipc/gateway-client.ts

@@ -98,12 +98,12 @@ export function resetPersistentClient(): void {
  */
 export async function ipcGetFeatureFlags(
   timeoutMs?: number,
-): Promise<Record<string, boolean>> {
+): Promise<Record<string, boolean | string>> {
   const result = await ipcCall("get_feature_flags", undefined, timeoutMs);
   if (result && typeof result === "object" && !Array.isArray(result)) {
-    const filtered: Record<string, boolean> = {};
+    const filtered: Record<string, boolean | string> = {};
     for (const [k, v] of Object.entries(result as Record<string, unknown>)) {
-      if (typeof v === "boolean") filtered[k] = v;
+      if (typeof v === "boolean" || typeof v === "string") filtered[k] = v;
     }
     return filtered;
   }

package/src/ipc/skill-routes/__tests__/memory.test.ts

@@ -137,6 +137,21 @@ describe("host.memory.addMessage", () => {
       }),
     ).rejects.toThrow();
   });
+
+  test("rejects the non-renderable system role", async () => {
+    // GIVEN the messages store is UI-facing (ConversationMessage), so only
+    // renderable turns may be persisted via this facet
+    // WHEN a skill attempts to add a system row
+    // THEN the route rejects it instead of persisting agent-context scaffolding
+    await expect(
+      memoryAddMessageRoute.handler({
+        conversationId: "c",
+        role: "system",
+        content: "agent-context scaffolding",
+      }),
+    ).rejects.toThrow();
+    expect(addMessageSpy).not.toHaveBeenCalled();
+  });
 });
 
 describe("host.memory.wakeAgentForOpportunity", () => {

package/src/ipc/skill-routes/memory.ts

@@ -17,7 +17,9 @@ import type { SkillIpcRoute } from "../skill-ipc-types.js";
 
 /**
  * IPC params for `addMessage()`. `role` is constrained to the
- * `MessageRole` union. `metadata` is a free-form record (validated
+ * renderable conversation roles (`user`/`assistant`): the messages store
+ * is UI-facing (`ConversationMessage`), so agent-context `system` rows are
+ * not accepted here. `metadata` is a free-form record (validated
  * downstream by `messageMetadataSchema` with a warn-and-store fallback).
  * `skipIndexing` and `clientMessageId` mirror `AddMessageOptions`.
  *
@@ -28,7 +30,7 @@ import type { SkillIpcRoute } from "../skill-ipc-types.js";
  */
 const MemoryAddMessageParams = z.object({
   conversationId: z.string().min(1),
-  role: z.enum(["user", "assistant", "system"]),
+  role: z.enum(["user", "assistant"]),
   content: z.string(),
   metadata: z.record(z.string(), z.unknown()).optional(),
   skipIndexing: z.boolean().optional(),

package/src/media/gemini-image-service.ts

@@ -5,6 +5,7 @@ import {
   type ImageGenCredentials,
   type ImageGenerationRequest,
   type ImageGenerationResult,
+  isImageProviderBillingError,
   type ManagedProxyCredentials,
   MAX_VARIANTS,
 } from "./types.js";
@@ -19,9 +20,18 @@ const ALLOWED_MODELS = new Set([
 
 // --- Error mapping ---
 
+const GEMINI_BILLING_MESSAGE =
+  "Image generation is unavailable because the Gemini account or API key is out of credits. " +
+  "Add funds with the provider or update the key in Settings — retrying won't help until credits are added.";
+
 export function mapGeminiError(error: unknown): string {
   if (error instanceof ApiError) {
     const status = error.status;
+    // Billing failures are non-retryable, so check them before the rate-limit
+    // branch to avoid telling the user to "wait and try again".
+    if (isImageProviderBillingError({ status, message: error.message })) {
+      return GEMINI_BILLING_MESSAGE;
+    }
     if (status === 400) {
       return "The image request was invalid. Please check your prompt and try again.";
     }
@@ -37,6 +47,11 @@ export function mapGeminiError(error: unknown): string {
     return `Gemini API error (status ${status}). Please try again.`;
   }
   if (error instanceof Error) {
+    // The managed proxy surfaces failures as plain Errors whose message embeds
+    // the upstream status (e.g. "Managed proxy request failed (402): ...").
+    if (isImageProviderBillingError({ message: error.message })) {
+      return GEMINI_BILLING_MESSAGE;
+    }
     return `Image generation failed: ${error.message}`;
   }
   return "An unexpected error occurred during image generation.";

package/src/media/openai-image-service.ts

@@ -6,6 +6,7 @@ import {
   type ImageGenCredentials,
   type ImageGenerationRequest,
   type ImageGenerationResult,
+  isImageProviderBillingError,
   MAX_VARIANTS,
 } from "./types.js";
 
@@ -16,6 +17,10 @@ const ALLOWED_MODELS = new Set(["gpt-image-2"]);
 
 // --- Error mapping ---
 
+const OPENAI_BILLING_MESSAGE =
+  "Image generation is unavailable because the OpenAI account or API key is out of credits. " +
+  "Add funds with the provider or update the key in Settings — retrying won't help until credits are added.";
+
 /**
  * Map an error raised by the OpenAI Images API to a user-friendly string.
  * Mirrors the status-code branches of `mapGeminiError` in
@@ -24,6 +29,12 @@ const ALLOWED_MODELS = new Set(["gpt-image-2"]);
 export function mapOpenAIError(error: unknown): string {
   if (error instanceof OpenAI.APIError) {
     const status = error.status;
+    // Billing failures are non-retryable and can surface as a 402 or as a 429
+    // with an `insufficient_quota` body, so check them before the rate-limit
+    // branch to avoid telling the user to "wait and try again".
+    if (isImageProviderBillingError({ status, message: error.message })) {
+      return OPENAI_BILLING_MESSAGE;
+    }
     if (status === 400) {
       return "The image request was invalid. Please check your prompt and try again.";
     }
@@ -39,6 +50,9 @@ export function mapOpenAIError(error: unknown): string {
     return `OpenAI API error (status ${status}). Please try again.`;
   }
   if (error instanceof Error) {
+    if (isImageProviderBillingError({ message: error.message })) {
+      return OPENAI_BILLING_MESSAGE;
+    }
     return `Image generation failed: ${error.message}`;
   }
   return "An unexpected error occurred during image generation.";

package/src/media/types.ts

@@ -44,3 +44,37 @@ export function providerForImageModelPrefix(model: string): ImageGenProvider {
   }
   return "gemini";
 }
+
+/**
+ * Message fragments that indicate a provider billing / insufficient-credits
+ * failure. Used by the per-provider error mappers to detect a non-retryable
+ * out-of-credits condition that no number of retries will resolve.
+ */
+const BILLING_MESSAGE_PATTERNS: readonly RegExp[] = [
+  /credit balance is too low/i,
+  /insufficient[\s_-]*credits?/i,
+  /insufficient_quota/i,
+  /exceeded your current quota/i,
+  /out of credits/i,
+  /requires more credits/i,
+  /billing/i,
+  /request failed \(402\)/i,
+];
+
+/**
+ * Detect a provider billing / insufficient-credits failure from an HTTP status
+ * and/or error message. A 402 status is billing by definition; otherwise the
+ * message is matched against known billing phrasings (OpenAI's
+ * `insufficient_quota` is reported as a 429, so status alone is insufficient).
+ *
+ * Billing failures are non-retryable: the user must add funds or update the API
+ * key. Callers surface a distinct message instead of a generic "try again".
+ */
+export function isImageProviderBillingError(args: {
+  status?: number;
+  message?: string;
+}): boolean {
+  if (args.status === 402) return true;
+  const message = args.message ?? "";
+  return BILLING_MESSAGE_PATTERNS.some((pattern) => pattern.test(message));
+}

package/src/memory/__tests__/jobs-worker-v2-schedule.test.ts

@@ -72,6 +72,7 @@ const CONSOLIDATE_CHECKPOINT_KEY = "memory_v2_consolidate_last_run";
 
 function buildConfig(overrides: {
   v2Enabled?: boolean;
+  consolidationEnabled?: boolean;
   intervalHours?: number;
   maxBufferLines?: number | null;
 }) {
@@ -79,6 +80,13 @@ function buildConfig(overrides: {
   if (overrides.v2Enabled !== undefined) {
     partial.memory.v2.enabled = overrides.v2Enabled;
   }
+  if (overrides.consolidationEnabled !== undefined) {
+    (
+      partial.memory.v2 as typeof partial.memory.v2 & {
+        consolidation_enabled?: boolean;
+      }
+    ).consolidation_enabled = overrides.consolidationEnabled;
+  }
   if (overrides.intervalHours !== undefined) {
     partial.memory.v2.consolidation_interval_hours = overrides.intervalHours;
   }
@@ -110,6 +118,15 @@ function countPendingJobs(type: string): number {
     .all().length;
 }
 
+function consolidationJobPayloads(): Record<string, unknown>[] {
+  return getDb()
+    .select({ payload: memoryJobs.payload })
+    .from(memoryJobs)
+    .where(eq(memoryJobs.type, "memory_v2_consolidate"))
+    .all()
+    .map((row) => JSON.parse(row.payload) as Record<string, unknown>);
+}
+
 // Initialize the DB once for the file; clear per-test tables in beforeEach
 // rather than tearing down the singleton, which is slow because it re-runs
 // every migration on the next access.
@@ -138,6 +155,7 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
     maybeEnqueueGraphMaintenanceJobs(config, Date.now());
 
     expect(countPendingJobs("memory_v2_consolidate")).toBe(1);
+    expect(consolidationJobPayloads()).toEqual([{ trigger: "automatic" }]);
     // v1 entries are suppressed when v2 is active.
     expect(countPendingJobs("graph_decay")).toBe(0);
     expect(countPendingJobs("graph_consolidate")).toBe(0);
@@ -170,6 +188,7 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
     maybeEnqueueGraphMaintenanceJobs(config, now);
 
     expect(countPendingJobs("memory_v2_consolidate")).toBe(1);
+    expect(consolidationJobPayloads()).toEqual([{ trigger: "automatic" }]);
   });
 
   test("respects a custom consolidation_interval_hours value", () => {
@@ -231,6 +250,28 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
     expect(countPendingJobs("graph_narrative_refine")).toBe(1);
     expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
   });
+
+  test("automatic consolidation off suppresses the v2 schedule without re-enabling v1 maintenance", () => {
+    const config = buildConfig({
+      v2Enabled: true,
+      consolidationEnabled: false,
+      intervalHours: 1,
+    });
+
+    deleteMemoryCheckpoint("graph_maintenance:decay:last_run");
+    deleteMemoryCheckpoint("graph_maintenance:consolidate:last_run");
+    deleteMemoryCheckpoint("graph_maintenance:pattern_scan:last_run");
+    deleteMemoryCheckpoint("graph_maintenance:narrative:last_run");
+    deleteMemoryCheckpoint(CONSOLIDATE_CHECKPOINT_KEY);
+
+    maybeEnqueueGraphMaintenanceJobs(config, Date.now());
+
+    expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
+    expect(countPendingJobs("graph_decay")).toBe(0);
+    expect(countPendingJobs("graph_consolidate")).toBe(0);
+    expect(countPendingJobs("graph_pattern_scan")).toBe(0);
+    expect(countPendingJobs("graph_narrative_refine")).toBe(0);
+  });
 });
 
 describe("maybeEnqueueGraphMaintenanceJobs — buffer-size trigger", () => {
@@ -369,4 +410,19 @@ describe("maybeEnqueueGraphMaintenanceJobs — buffer-size trigger", () => {
 
     expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
   });
+
+  test("size trigger inert when automatic consolidation is disabled", () => {
+    const config = buildConfig({
+      v2Enabled: true,
+      consolidationEnabled: false,
+      intervalHours: 1,
+      maxBufferLines: 1,
+    });
+
+    writeBuffer(100);
+
+    maybeEnqueueGraphMaintenanceJobs(config, Date.now());
+
+    expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
+  });
 });

package/src/memory/auth-fallback-events-store.ts

@@ -0,0 +1,94 @@
+import { and, asc, eq, gt, or } from "drizzle-orm";
+import { v4 as uuid } from "uuid";
+
+import { getConfig } from "../config/loader.js";
+import { getDb } from "./db-connection.js";
+import { authFallbackEvents } from "./schema.js";
+
+/** A single aggregated auth-fallback count for one (guard, path, failure_kind). */
+export interface AuthFallbackCount {
+  guard: string;
+  path: string;
+  failureKind: string;
+  count: number;
+}
+
+/** A persisted auth-fallback event row. */
+export interface AuthFallbackEvent {
+  id: string;
+  createdAt: number;
+  guard: string;
+  path: string;
+  failureKind: string;
+  count: number;
+  windowStart: number;
+  windowEnd: number;
+}
+
+/**
+ * Record a batch of aggregated auth-fallback counts forwarded by the gateway —
+ * one row per count entry, all sharing the same flush window. Returns the
+ * number of rows recorded, or 0 when usage data collection is disabled (the
+ * counts are dropped to honor the opt-out, matching the rest of telemetry).
+ */
+export function recordAuthFallbackCounts(
+  windowStart: number,
+  windowEnd: number,
+  counts: AuthFallbackCount[],
+): number {
+  if (!getConfig().collectUsageData) return 0;
+  if (counts.length === 0) return 0;
+  const db = getDb();
+  const createdAt = Date.now();
+  const rows = counts.map((c) => ({
+    id: uuid(),
+    createdAt,
+    guard: c.guard,
+    path: c.path,
+    failureKind: c.failureKind,
+    count: c.count,
+    windowStart,
+    windowEnd,
+  }));
+  db.insert(authFallbackEvents).values(rows).run();
+  return rows.length;
+}
+
+/**
+ * Query auth-fallback events that haven't been reported to telemetry yet.
+ * Uses a compound cursor (createdAt + id) for reliable watermarking.
+ */
+export function queryUnreportedAuthFallbackEvents(
+  afterCreatedAt: number,
+  afterId: string | undefined,
+  limit: number,
+): AuthFallbackEvent[] {
+  const db = getDb();
+  const rows = db
+    .select({
+      id: authFallbackEvents.id,
+      createdAt: authFallbackEvents.createdAt,
+      guard: authFallbackEvents.guard,
+      path: authFallbackEvents.path,
+      failureKind: authFallbackEvents.failureKind,
+      count: authFallbackEvents.count,
+      windowStart: authFallbackEvents.windowStart,
+      windowEnd: authFallbackEvents.windowEnd,
+    })
+    .from(authFallbackEvents)
+    .where(
+      afterId
+        ? or(
+            gt(authFallbackEvents.createdAt, afterCreatedAt),
+            and(
+              eq(authFallbackEvents.createdAt, afterCreatedAt),
+              gt(authFallbackEvents.id, afterId),
+            ),
+          )
+        : gt(authFallbackEvents.createdAt, afterCreatedAt),
+    )
+    .orderBy(asc(authFallbackEvents.createdAt), asc(authFallbackEvents.id))
+    .limit(limit)
+    .all();
+  return rows;
+}

package/src/memory/conversation-starter-checkpoints.ts

@@ -15,6 +15,7 @@ import { memoryCheckpoints } from "./schema.js";
 export const CK_ITEM_COUNT = "conversation_starters:item_count_at_last_gen";
 export const CK_BATCH = "conversation_starters:generation_batch";
 export const CK_LAST_GEN_AT = "conversation_starters:last_gen_at";
+export const CK_LAST_ATTEMPT_AT = "conversation_starters:last_attempt_at";
 
 export function checkpointKey(base: string, scopeId: string): string {
   return `${base}:${scopeId}`;