@vellumai/assistant 0.8.0 → 0.8.2

package/src/__tests__/app-executors.test.ts

@@ -1,13 +1,31 @@
-import { describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+type CompileResult = {
+  ok: boolean;
+  errors: string[];
+  warnings: string[];
+  durationMs: number;
+};
+
+let compileResultOverride: CompileResult = {
+  ok: true,
+  errors: [],
+  warnings: [],
+  durationMs: 0,
+};
 
 mock.module("../bundler/app-compiler.js", () => ({
-  compileApp: async () => ({
+  compileApp: async () => compileResultOverride,
+}));
+
+beforeEach(() => {
+  compileResultOverride = {
     ok: true,
     errors: [],
     warnings: [],
     durationMs: 0,
-  }),
-}));
+  };
+});
 
 import type { AppDefinition } from "../memory/app-store.js";
 import type { AppStore } from "../tools/apps/executors.js";
@@ -102,6 +120,204 @@ describe("executeAppCreate", () => {
     expect(files["src/main.tsx"]).toBeDefined();
     expect(files["src/main.tsx"]).toContain("import { render } from 'preact'");
     expect(files["src/main.tsx"]).toContain('{"Hello, New App!"}');
+    // next_steps directive must be present so the model keeps writing
+    // real source files instead of treating the scaffold as done.
+    const parsed = JSON.parse(result.content);
+    expect(parsed.next_steps).toContain("placeholder src/main.tsx");
+    expect(parsed.next_steps).toContain("app_refresh");
+  });
+
+  test("skips auto_open on scaffold even when proxy resolver is available", async () => {
+    const files: Record<string, string> = {};
+    const app = makeMultifileApp({ name: "New App" });
+    const store: AppStore = {
+      ...mockStore(app, files),
+      createApp: () => app,
+    };
+    let proxyCalled = false;
+    const proxyResolver = async () => {
+      proxyCalled = true;
+      return { content: JSON.stringify({ opened: true }), isError: false };
+    };
+
+    const result = await executeAppCreate(
+      { name: "New App" },
+      store,
+      proxyResolver,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(proxyCalled).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(parsed.auto_opened).toBeUndefined();
+    expect(parsed.next_steps).toContain("placeholder src/main.tsx");
+    expect(parsed.next_steps).toContain("app_refresh");
+  });
+
+  test("omits next_steps when main.tsx was pre-written before app_create", async () => {
+    // The agent's supported workflow is to write the real source files first
+    // and then call app_create. In that case the placeholder directive would
+    // be false and risk triggering a destructive rewrite of correct code.
+    const files: Record<string, string> = {
+      "src/main.tsx": "// real code from the agent",
+    };
+    const app = makeMultifileApp({ name: "Pre-written App" });
+    const store: AppStore = {
+      ...mockStore(app, files),
+      createApp: () => app,
+    };
+
+    const result = await executeAppCreate({ name: "Pre-written App" }, store);
+
+    expect(result.isError).toBe(false);
+    // The pre-written file must be preserved
+    expect(files["src/main.tsx"]).toBe("// real code from the agent");
+    const parsed = JSON.parse(result.content);
+    expect(parsed.next_steps).toBeUndefined();
+  });
+
+  test("includes next_steps when compile fails on the scaffold", async () => {
+    compileResultOverride = {
+      ok: false,
+      errors: ["unexpected token"],
+      warnings: [],
+      durationMs: 3,
+    };
+    const files: Record<string, string> = {};
+    const app = makeMultifileApp({ name: "Broken App" });
+    const store: AppStore = {
+      ...mockStore(app, files),
+      createApp: () => app,
+    };
+
+    const result = await executeAppCreate({ name: "Broken App" }, store);
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(parsed.compile_errors).toEqual(["unexpected token"]);
+    expect(parsed.next_steps).toContain("placeholder src/main.tsx");
+    expect(parsed.next_steps).toContain("app_refresh");
+  });
+
+  test("omits next_steps when compile fails on pre-written files", async () => {
+    compileResultOverride = {
+      ok: false,
+      errors: ["unexpected token"],
+      warnings: [],
+      durationMs: 3,
+    };
+    const files: Record<string, string> = {
+      "src/main.tsx": "// agent's real (but broken) code",
+    };
+    const app = makeMultifileApp({ name: "Broken Pre-written App" });
+    const store: AppStore = {
+      ...mockStore(app, files),
+      createApp: () => app,
+    };
+
+    const result = await executeAppCreate(
+      { name: "Broken Pre-written App" },
+      store,
+    );
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(parsed.compile_errors).toEqual(["unexpected token"]);
+    expect(parsed.next_steps).toBeUndefined();
+  });
+
+  test("suppresses auto_open when only scaffold exists", async () => {
+    const files: Record<string, string> = {};
+    const app = makeMultifileApp({ name: "New App" });
+    const store: AppStore = {
+      ...mockStore(app, files),
+      createApp: () => app,
+    };
+    let proxyCalledWith: Record<string, unknown> | undefined;
+    const proxyResolver = async (
+      toolName: string,
+      input: Record<string, unknown>,
+    ) => {
+      proxyCalledWith = { toolName, input };
+      return { content: JSON.stringify({ opened: true }), isError: false };
+    };
+
+    const result = await executeAppCreate(
+      { name: "New App" },
+      store,
+      proxyResolver,
+    );
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(proxyCalledWith).toBeUndefined();
+    expect(parsed.auto_opened).toBeUndefined();
+    expect(parsed.next_steps).toContain("placeholder src/main.tsx");
+  });
+
+  test("fires auto_open when source_files includes main.tsx", async () => {
+    const files: Record<string, string> = {};
+    const app = makeMultifileApp({ name: "Real App" });
+    const store: AppStore = {
+      ...mockStore(app, files),
+      createApp: () => app,
+    };
+    let proxyCalledWith: Record<string, unknown> | undefined;
+    const proxyResolver = async (
+      toolName: string,
+      input: Record<string, unknown>,
+    ) => {
+      proxyCalledWith = { toolName, input };
+      return { content: JSON.stringify({ opened: true }), isError: false };
+    };
+
+    const result = await executeAppCreate(
+      {
+        name: "Real App",
+        source_files: {
+          "src/main.tsx":
+            "import { render } from 'preact';\nrender(<div>Real</div>, document.getElementById('app')!);",
+          "src/styles.css": "body { margin: 0; }",
+        },
+      },
+      store,
+      proxyResolver,
+    );
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(proxyCalledWith).toBeDefined();
+    expect(parsed.auto_opened).toBe(true);
+    expect(parsed.next_steps).toBeUndefined();
+    expect(files["src/main.tsx"]).toContain("Real");
+    expect(files["src/styles.css"]).toContain("margin");
+  });
+
+  test("source_files are written and prevent scaffold", async () => {
+    const files: Record<string, string> = {};
+    const app = makeMultifileApp({ name: "Inline App" });
+    const store: AppStore = {
+      ...mockStore(app, files),
+      createApp: () => app,
+    };
+
+    const result = await executeAppCreate(
+      {
+        name: "Inline App",
+        source_files: {
+          "src/main.tsx": "// custom app code",
+          "src/components/App.tsx": "// App component",
+        },
+      },
+      store,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(files["src/main.tsx"]).toBe("// custom app code");
+    expect(files["src/components/App.tsx"]).toBe("// App component");
+    expect(files["src/index.html"]).toBeDefined();
+    const parsed = JSON.parse(result.content);
+    expect(parsed.next_steps).toBeUndefined();
   });
 
   test("rejects retired html shortcut", async () => {

package/src/__tests__/assistant-events-sse-shed.test.ts

@@ -0,0 +1,232 @@
+/**
+ * Tests for SSE subscriber shed-on-backpressure observability.
+ *
+ * Verifies that when `controller.desiredSize <= 0`, the SSE route invokes
+ * the injected shed reporter with the correct reason and per-subscriber
+ * context. Both shed sites are covered: the event-callback path (slow
+ * subscriber + publishes filling the queue) and the heartbeat-timer path
+ * (slow subscriber with no published events). The healthy path asserts
+ * no shed report fires.
+ */
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { buildAssistantEvent } from "../runtime/assistant-event.js";
+import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
+import {
+  buildSseShedSentryContext,
+  handleSubscribeAssistantEvents,
+  type SseShedReason,
+  type SseSubscriberInstrumentation,
+} from "../runtime/routes/events-routes.js";
+
+initializeDb();
+
+function clearTables() {
+  const db = getDb();
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM conversations");
+}
+
+interface ShedReport {
+  reason: SseShedReason;
+  events_delivered: number;
+  heartbeats_sent: number;
+  client_id: string | null;
+  interface_id: string | null;
+  conversation_key: string | null;
+  subscription_age_ms: number;
+}
+
+function makeReporterCaptor(): {
+  reports: ShedReport[];
+  reporter: (reason: SseShedReason, inst: SseSubscriberInstrumentation) => void;
+} {
+  const reports: ShedReport[] = [];
+  return {
+    reports,
+    reporter: (reason, inst) => {
+      reports.push({
+        reason,
+        events_delivered: inst.eventsDelivered,
+        heartbeats_sent: inst.heartbeatsSent,
+        client_id: inst.clientId,
+        interface_id: inst.interfaceId,
+        conversation_key: inst.conversationKey,
+        subscription_age_ms: Date.now() - inst.subscribedAtMs,
+      });
+    },
+  };
+}
+
+const SSE_HIGH_WATER_MARK = 16;
+
+describe("SSE route — backpressure shed observability", () => {
+  beforeEach(clearTables);
+
+  test("invokes shedReporter with reason=callback_backpressure when publishes saturate the queue", async () => {
+    const hub = new AssistantEventHub();
+    const { reports, reporter } = makeReporterCaptor();
+    const ac = new AbortController();
+
+    handleSubscribeAssistantEvents(
+      {
+        queryParams: { conversationKey: "shed-cb-test" },
+        abortSignal: ac.signal,
+      },
+      { hub, shedReporter: reporter },
+    );
+    expect(hub.subscriberCount()).toBe(1);
+
+    // Saturate the stream's bounded queue without reading from it.
+    // start() already enqueued the immediate heartbeat (queue=1), so
+    // publishing `SSE_HIGH_WATER_MARK` events triggers the shed on the
+    // final publish when desiredSize hits 0.
+    for (let i = 0; i < SSE_HIGH_WATER_MARK; i += 1) {
+      await hub.publish(buildAssistantEvent({ type: "pong" }));
+    }
+
+    expect(hub.subscriberCount()).toBe(0);
+    expect(reports.length).toBe(1);
+    expect(reports[0]?.reason).toBe("callback_backpressure");
+    expect(reports[0]?.events_delivered).toBe(SSE_HIGH_WATER_MARK - 1);
+    // The initial heartbeat enqueued by start() must be counted so the
+    // reported queue depth matches what was actually pushed.
+    expect(reports[0]?.heartbeats_sent).toBe(1);
+    expect(reports[0]?.conversation_key).toBe("shed-cb-test");
+    expect(typeof reports[0]?.subscription_age_ms).toBe("number");
+
+    ac.abort();
+  });
+
+  test("invokes shedReporter with reason=heartbeat_backpressure when the heartbeat tick finds desiredSize<=0", async () => {
+    const hub = new AssistantEventHub();
+    const { reports, reporter } = makeReporterCaptor();
+    const ac = new AbortController();
+
+    handleSubscribeAssistantEvents(
+      {
+        queryParams: { conversationKey: "shed-hb-test" },
+        abortSignal: ac.signal,
+      },
+      { hub, heartbeatIntervalMs: 20, shedReporter: reporter },
+    );
+    expect(hub.subscriberCount()).toBe(1);
+
+    // Fill the queue up to its limit without sending the publish that
+    // would shed via the callback path.
+    for (let i = 0; i < SSE_HIGH_WATER_MARK - 1; i += 1) {
+      await hub.publish(buildAssistantEvent({ type: "pong" }));
+    }
+    expect(reports.length).toBe(0);
+
+    await new Promise((r) => setTimeout(r, 60));
+
+    expect(reports.length).toBe(1);
+    expect(reports[0]?.reason).toBe("heartbeat_backpressure");
+    expect(reports[0]?.conversation_key).toBe("shed-hb-test");
+
+    ac.abort();
+  });
+
+  test("does not invoke shedReporter when a reader drains the stream", async () => {
+    const hub = new AssistantEventHub();
+    const { reports, reporter } = makeReporterCaptor();
+    const ac = new AbortController();
+
+    const stream = handleSubscribeAssistantEvents(
+      {
+        queryParams: { conversationKey: "shed-healthy-test" },
+        abortSignal: ac.signal,
+      },
+      { hub, heartbeatIntervalMs: 1_000, shedReporter: reporter },
+    );
+
+    const reader = stream.getReader();
+    void reader.read();
+
+    for (let i = 0; i < 32; i += 1) {
+      await hub.publish(buildAssistantEvent({ type: "pong" }));
+      void reader.read();
+    }
+
+    expect(reports.length).toBe(0);
+
+    ac.abort();
+    void reader.cancel();
+  });
+
+  test("captures client identity in the shed instrumentation context", async () => {
+    const hub = new AssistantEventHub();
+    const { reports, reporter } = makeReporterCaptor();
+    const ac = new AbortController();
+
+    handleSubscribeAssistantEvents(
+      {
+        queryParams: { conversationKey: "shed-client-test" },
+        headers: {
+          "x-vellum-client-id": "client-abc",
+          "x-vellum-interface-id": "macos",
+        },
+        abortSignal: ac.signal,
+      },
+      { hub, shedReporter: reporter },
+    );
+
+    for (let i = 0; i < SSE_HIGH_WATER_MARK; i += 1) {
+      await hub.publish(buildAssistantEvent({ type: "pong" }));
+    }
+
+    expect(reports.length).toBe(1);
+    expect(reports[0]?.client_id).toBe("client-abc");
+    expect(reports[0]?.interface_id).toBe("macos");
+
+    ac.abort();
+  });
+});
+
+describe("buildSseShedSentryContext", () => {
+  const inst: SseSubscriberInstrumentation = {
+    subscribedAtMs: 1_000,
+    eventsDelivered: 7,
+    heartbeatsSent: 3,
+    clientId: "client-xyz",
+    interfaceId: "macos",
+    // Channel-backed conversation key embedding a phone number.
+    conversationKey: "asst:self:whatsapp:447123456789",
+  };
+  const elDelay = { mean_ms: 1.2, p99_ms: 3.4, max_ms: 5.6 };
+
+  test("omits conversation_key so Sentry contexts do not leak PII", () => {
+    const ctx = buildSseShedSentryContext(
+      "callback_backpressure",
+      inst,
+      elDelay,
+      2_500,
+    );
+    expect(ctx).not.toHaveProperty("conversation_key");
+    expect(ctx).not.toHaveProperty("conversationKey");
+    expect(JSON.stringify(ctx)).not.toContain("447123456789");
+  });
+
+  test("preserves non-PII per-subscriber and runtime fields", () => {
+    const ctx = buildSseShedSentryContext(
+      "heartbeat_backpressure",
+      inst,
+      elDelay,
+      2_500,
+    );
+    expect(ctx).toMatchObject({
+      reason: "heartbeat_backpressure",
+      subscription_age_ms: 1_500,
+      events_delivered: 7,
+      heartbeats_sent: 3,
+      client_id: "client-xyz",
+      interface_id: "macos",
+      event_loop_delay_mean_ms: 1.2,
+      event_loop_delay_p99_ms: 3.4,
+      event_loop_delay_max_ms: 5.6,
+    });
+  });
+});

package/src/__tests__/auto-analysis-end-to-end.test.ts

@@ -585,3 +585,38 @@ describe("indexer v1/v2 mutual exclusion for graph_extract", () => {
     );
   });
 });
+
+// ─────────────────────────────────────────────────────────────────
+// Indexer v1/v2 mutual exclusion: build_conversation_summary feeds
+// v1-only readers (fetchRecentSummaries, semantic search). When
+// memory.v2.enabled is on, the summary writes are unread, so the
+// indexer must not enqueue them.
+// ─────────────────────────────────────────────────────────────────
+
+describe("indexer v1/v2 mutual exclusion for build_conversation_summary", () => {
+  const originalV2Enabled = TEST_CONFIG.memory.v2.enabled;
+
+  afterEach(() => {
+    TEST_CONFIG.memory.v2.enabled = originalV2Enabled;
+  });
+
+  test("v2 active (config on) → build_conversation_summary not enqueued", async () => {
+    TEST_CONFIG.memory.v2.enabled = true;
+
+    const source = createConversation("summary-v2-active");
+    await indexMessages(source.id, 2);
+
+    expect(countJobsOfType("build_conversation_summary", source.id)).toBe(0);
+  });
+
+  test("config gate off → build_conversation_summary enqueued", async () => {
+    TEST_CONFIG.memory.v2.enabled = false;
+
+    const source = createConversation("summary-v2-config-off");
+    await indexMessages(source.id, 2);
+
+    expect(
+      countJobsOfType("build_conversation_summary", source.id),
+    ).toBeGreaterThanOrEqual(1);
+  });
+});

package/src/__tests__/avatar-identity-sync.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, test } from "bun:test";
+
+import { SYNC_TAGS } from "../daemon/message-types/sync.js";
+import type { AssistantEvent } from "../runtime/assistant-event.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { ROUTES as AVATAR_ROUTES } from "../runtime/routes/avatar-routes.js";
+import { publishIdentityChanged } from "../runtime/sync/resource-sync-events.js";
+
+async function waitFor(predicate: () => boolean): Promise<void> {
+  const deadline = Date.now() + 500;
+  while (Date.now() < deadline) {
+    if (predicate()) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+  throw new Error("Timed out waiting for avatar/identity sync event");
+}
+
+describe("avatar and identity sync events", () => {
+  test("notify_avatar_updated emits legacy avatar event and sync tag", async () => {
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+
+    try {
+      const route = AVATAR_ROUTES.find(
+        (candidate) => candidate.operationId === "notify_avatar_updated",
+      );
+      expect(route).toBeDefined();
+
+      await route!.handler({});
+      await waitFor(() => received.length === 2);
+
+      expect(received.map((event) => event.message.type)).toEqual([
+        "avatar_updated",
+        "sync_changed",
+      ]);
+      expect(received[1].message).toEqual({
+        type: "sync_changed",
+        tags: [SYNC_TAGS.assistantAvatar],
+      });
+    } finally {
+      subscription.dispose();
+    }
+  });
+
+  test("identity changes emit legacy identity event and sync tag", async () => {
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+
+    try {
+      publishIdentityChanged({
+        name: "Sage",
+        role: "Assistant",
+        personality: "Calm",
+        emoji: ":sparkles:",
+        home: "San Francisco",
+      });
+      await waitFor(() => received.length === 2);
+
+      expect(received.map((event) => event.message.type)).toEqual([
+        "identity_changed",
+        "sync_changed",
+      ]);
+      expect(received[0].message).toMatchObject({
+        type: "identity_changed",
+        name: "Sage",
+      });
+      expect(received[1].message).toEqual({
+        type: "sync_changed",
+        tags: [SYNC_TAGS.assistantIdentity],
+      });
+    } finally {
+      subscription.dispose();
+    }
+  });
+});

package/src/__tests__/background-workers-disk-pressure.test.ts

@@ -1,5 +1,12 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+// Default the warm-pool gate to OPEN — these tests probe background-job
+// disk-pressure behavior, not the pre-first-message guard.
+mock.module("../runtime/pre-first-message-gate.js", () => ({
+  hasReceivedUserMessage: () => true,
+  _resetPreFirstMessageGateCacheForTests: () => {},
+}));
+
 mock.module("../util/logger.js", () => ({
   getLogger: () => ({
     info: () => {},
@@ -107,11 +114,13 @@ mock.module("../memory/conversation-crud.js", () => ({
     return { id: "conv-1", ...opts };
   },
   countConversationsByScheduleJobId: mock(() => 0),
+  countMessagesAfter: mock(() => 0),
   deleteMessageById: mock(() => {}),
   clearAll: mock(() => ({ conversations: 0, messages: 0 })),
   deleteConversation: mock(() => ({ memoryIds: [] })),
   deleteLastExchange: mock(() => 0),
   findAnalysisConversationFor: mock(() => null),
+  findMostRecentRetrospectiveFor: mock(() => null),
   forkConversation: mock(() => ({ id: "conv-fork" })),
   getConversationOverrideProfile: () => undefined,
   getConversationOverrideProfileFromRow: () => undefined,
@@ -126,6 +135,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getLastUserTimestampBefore: () => null,
   getMessageById: () => null,
   getMessages: () => [],
+  getMessagesAfter: () => [],
   getMessagesPaginated: () => ({ messages: [], hasMore: false }),
   getTurnTimeBounds: () => null,
   getConversation: () => null,
@@ -175,6 +185,7 @@ mock.module("../memory/jobs-store.js", () => ({
   SLOW_LLM_JOB_TYPES: [],
   upsertAutoAnalysisJob: mock(() => "job-auto-analysis"),
   upsertDebouncedJob: mock(() => "job-debounced"),
+  upsertMemoryRetrospectiveJob: mock(() => "job-memory-retrospective"),
 }));
 
 const mockMaybeRunDbMaintenance = mock(() => {});
@@ -187,7 +198,6 @@ mock.module("../memory/cleanup-schedule-state.js", () => ({
   markScheduledCleanupEnqueued: mock(() => {}),
 }));
 
-const { startFeedScheduler } = await import("../home/feed-scheduler.js");
 const { runMemoryJobsOnce } = await import("../memory/jobs-worker.js");
 const { FilingService } = await import("../filing/filing-service.js");
 const { WorkspaceHeartbeatService } =
@@ -202,27 +212,6 @@ describe("background workers disk pressure gate", () => {
     mockMaybeRunDbMaintenance.mockClear();
   });
 
-  test("home feed scheduler skips producers while locked", async () => {
-    const gmailDigestRunner = mock(async () => null);
-    const rollupRunner = mock(async () => ({
-      wroteCount: 1,
-      skippedReason: "empty_items" as const,
-    }));
-    const handle = startFeedScheduler({
-      runOnStart: false,
-      gmailCountSource: async () => 0,
-      gmailDigestRunner,
-      rollupRunner,
-    });
-
-    const summary = await handle.runOnce(new Date("2026-05-05T12:00:00.000Z"));
-    handle.stop();
-
-    expect(summary).toEqual({ gmailDigestRan: false, rollupRan: false });
-    expect(gmailDigestRunner).not.toHaveBeenCalled();
-    expect(rollupRunner).not.toHaveBeenCalled();
-  });
-
   test("memory jobs worker skips before claiming or maintenance writes", async () => {
     const processed = await runMemoryJobsOnce({ enableScheduledCleanup: true });
 

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

@@ -320,6 +320,7 @@ describe("POST /v1/btw", () => {
     expect(mockBuildSystemPrompt).toHaveBeenCalledWith({
       channelPersona: null,
       excludeBootstrap: true,
+      excludeCustomPrefix: true,
       userPersona: null,
       userSlug: null,
     });