@vellumai/assistant 0.8.5 → 0.8.6

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

@@ -5,7 +5,6 @@ import type { DiskUsageInfo } from "../util/disk-usage.js";
 
 let diskSample: DiskUsageInfo | null = null;
 let diskSampleError: unknown = null;
-let diskSampleCalls = 0;
 
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({}),
@@ -13,7 +12,6 @@ mock.module("../config/loader.js", () => ({
 
 mock.module("../util/disk-usage.js", () => ({
   getDiskUsageInfo: () => {
-    diskSampleCalls += 1;
     if (diskSampleError) throw diskSampleError;
     return diskSample;
   },
@@ -38,9 +36,8 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
   },
 }));
 
-const { _setOverridesForTesting } =
-  await import("../config/assistant-feature-flags.js");
 const {
+  DISK_PRESSURE_CLEAR_THRESHOLD_PERCENT,
   DISK_PRESSURE_OVERRIDE_CONFIRMATION,
   DISK_PRESSURE_THRESHOLD_PERCENT,
   __getDiskPressureGuardTimerForTests,
@@ -53,10 +50,6 @@ const {
   stopDiskPressureGuard,
 } = await import("../daemon/disk-pressure-guard.js");
 
-function setFeatureFlag(enabled: boolean): void {
-  _setOverridesForTesting({ "safe-storage-limits": enabled });
-}
-
 function setDiskUsage(usedMb: number, totalMb = 100): void {
   diskSample = {
     path: "/workspace",
@@ -80,35 +73,16 @@ function expectRejected(
 
 beforeEach(() => {
   __resetDiskPressureGuardForTests();
-  setFeatureFlag(true);
   setDiskUsage(10);
-  diskSampleCalls = 0;
 });
 
 afterEach(() => {
   __resetDiskPressureGuardForTests();
-  _setOverridesForTesting({});
   diskSample = null;
   diskSampleError = null;
-  diskSampleCalls = 0;
 });
 
 describe("disk pressure guard", () => {
-  test("returns a stable disabled status without sampling when the flag is disabled", () => {
-    setDiskUsage(99);
-    setFeatureFlag(false);
-
-    const status = evaluateDiskPressureNow();
-
-    expect(status.enabled).toBe(false);
-    expect(status.state).toBe("disabled");
-    expect(status.locked).toBe(false);
-    expect(status.effectivelyLocked).toBe(false);
-    expect(status.usagePercent).toBeNull();
-    expect(diskSampleCalls).toBe(0);
-    expect(getDiskPressureStatus()).toEqual(status);
-  });
-
   test("locks when sampled usage reaches the threshold", () => {
     setDiskUsage(DISK_PRESSURE_THRESHOLD_PERCENT);
 
@@ -158,6 +132,63 @@ describe("disk pressure guard", () => {
     expect(status.blockedCapabilities).toEqual([]);
   });
 
+  test("does not lock within the deadband until usage reaches the critical threshold", () => {
+    setDiskUsage(DISK_PRESSURE_CLEAR_THRESHOLD_PERCENT + 2);
+
+    const status = evaluateDiskPressureNow();
+
+    expect(status.state).toBe("warning");
+    expect(status.locked).toBe(false);
+    expect(status.effectivelyLocked).toBe(false);
+  });
+
+  test("stays locked while usage stays within the hysteresis deadband", () => {
+    setDiskUsage(DISK_PRESSURE_THRESHOLD_PERCENT + 1);
+    const locked = evaluateDiskPressureNow();
+    expect(locked.locked).toBe(true);
+    const { lockId } = locked;
+
+    // Below critical (95) but above clear (90): must hold, not flap.
+    setDiskUsage(DISK_PRESSURE_CLEAR_THRESHOLD_PERCENT + 2);
+    const status = evaluateDiskPressureNow();
+
+    expect(status.state).toBe("critical");
+    expect(status.locked).toBe(true);
+    expect(status.effectivelyLocked).toBe(true);
+    // Same lock id — the dip did not mint a fresh lock.
+    expect(status.lockId).toBe(lockId);
+  });
+
+  test("preserves acknowledgement across a dip within the deadband", () => {
+    setDiskUsage(DISK_PRESSURE_THRESHOLD_PERCENT + 1);
+    evaluateDiskPressureNow();
+    acknowledgeDiskPressureLock();
+
+    setDiskUsage(DISK_PRESSURE_CLEAR_THRESHOLD_PERCENT + 2);
+    const status = evaluateDiskPressureNow();
+
+    expect(status.locked).toBe(true);
+    expect(status.acknowledged).toBe(true);
+  });
+
+  test("clears the lock only once usage falls below the clear threshold", () => {
+    setDiskUsage(DISK_PRESSURE_THRESHOLD_PERCENT + 1);
+    evaluateDiskPressureNow();
+
+    // Still within the deadband: locked.
+    setDiskUsage(DISK_PRESSURE_CLEAR_THRESHOLD_PERCENT + 2);
+    expect(evaluateDiskPressureNow().locked).toBe(true);
+
+    // Below the clear threshold: released.
+    setDiskUsage(DISK_PRESSURE_CLEAR_THRESHOLD_PERCENT - 2);
+    const status = evaluateDiskPressureNow();
+
+    expect(status.locked).toBe(false);
+    expect(status.effectivelyLocked).toBe(false);
+    expect(status.lockId).toBeNull();
+    expect(status.blockedCapabilities).toEqual([]);
+  });
+
   test("overrides an active lock only with the exact confirmation after trimming whitespace", () => {
     setDiskUsage(99);
     evaluateDiskPressureNow();
@@ -245,18 +276,4 @@ describe("disk pressure guard", () => {
     stopDiskPressureGuard();
     expect(__getDiskPressureGuardTimerForTests()).toBeNull();
   });
-
-  test("disabling the flag clears an active timer and lock", () => {
-    setDiskUsage(99);
-    evaluateDiskPressureNow();
-    startDiskPressureGuard();
-    expect(__getDiskPressureGuardTimerForTests()).toBeTruthy();
-
-    setFeatureFlag(false);
-    const status = evaluateDiskPressureNow();
-
-    expect(status.enabled).toBe(false);
-    expect(status.locked).toBe(false);
-    expect(__getDiskPressureGuardTimerForTests()).toBeNull();
-  });
 });

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

@@ -1,5 +1,7 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { createMockLoggerModule } from "./helpers/mock-logger.js";
+
 const warnCalls: unknown[] = [];
 let guardEnabled = true;
 let startCalls = 0;
@@ -81,17 +83,18 @@ mock.module("../daemon/disk-pressure-guard.js", () => ({
   DISK_PRESSURE_OVERRIDE_CONFIRMATION: "I understand the risks",
 }));
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () => ({
-    debug: () => {},
-    error: () => {},
-    info: () => {},
-    warn: (...args: unknown[]) => {
-      warnCalls.push(args);
-    },
+mock.module("../util/logger.js", () =>
+  createMockLoggerModule({
+    getLogger: () => ({
+      debug: () => {},
+      error: () => {},
+      info: () => {},
+      warn: (...args: unknown[]) => {
+        warnCalls.push(args);
+      },
+    }),
   }),
-  initLogger: () => {},
-}));
+);
 
 const {
   startDiskPressureGuardForLifecycle,

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

@@ -42,8 +42,6 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
   },
 }));
 
-const { _setOverridesForTesting } =
-  await import("../config/assistant-feature-flags.js");
 const {
   DISK_PRESSURE_OVERRIDE_CONFIRMATION,
   DISK_PRESSURE_THRESHOLD_PERCENT,
@@ -73,10 +71,6 @@ type DiskPressureRouteResult = {
   };
 };
 
-function setFeatureFlag(enabled: boolean): void {
-  _setOverridesForTesting({ "safe-storage-limits": enabled });
-}
-
 function setDiskUsage(usedMb: number, totalMb = 100): void {
   diskSample = {
     path: "/workspace",
@@ -137,13 +131,11 @@ async function flushPublishedEvents(): Promise<void> {
 
 beforeEach(() => {
   __resetDiskPressureGuardForTests();
-  setFeatureFlag(true);
   setDiskUsage(10);
 });
 
 afterEach(() => {
   __resetDiskPressureGuardForTests();
-  _setOverridesForTesting({});
   diskSample = null;
   eventSubscribers.clear();
 });
@@ -164,31 +156,6 @@ describe("disk pressure routes", () => {
     }
   });
 
-  test("returns disabled status without error when the feature flag is off", async () => {
-    setFeatureFlag(false);
-    setDiskUsage(99);
-
-    const result = await callRoute("disk-pressure/status", "GET");
-
-    expect(result.status).toMatchObject({
-      enabled: false,
-      state: "disabled",
-      locked: false,
-      acknowledged: false,
-      overrideActive: false,
-      effectivelyLocked: false,
-      lockId: null,
-      usagePercent: null,
-      path: null,
-      lastCheckedAt: null,
-      blockedCapabilities: [],
-      error: null,
-    });
-    expect(result.status.thresholdPercent).toBe(
-      DISK_PRESSURE_THRESHOLD_PERCENT,
-    );
-  });
-
   test("returns the full status shape for an active lock", async () => {
     setDiskUsage(99);
     evaluateDiskPressureNow();

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

@@ -80,8 +80,6 @@ mock.module("../util/disk-usage.js", () => ({
   getDiskUsageInfo: () => diskSample,
 }));
 
-const { _setOverridesForTesting } =
-  await import("../config/assistant-feature-flags.js");
 const {
   DISK_PRESSURE_THRESHOLD_PERCENT,
   __resetDiskPressureGuardForTests,
@@ -127,14 +125,12 @@ function setDiskUsage(usedMb: number, totalMb = 100): void {
 beforeEach(() => {
   _clearRegistryForTesting();
   __resetDiskPressureGuardForTests();
-  _setOverridesForTesting({ "safe-storage-limits": true });
   setDiskUsage(10);
 });
 
 afterEach(() => {
   _clearRegistryForTesting();
   __resetDiskPressureGuardForTests();
-  _setOverridesForTesting({});
   diskSample = null;
 });
 

package/src/__tests__/dm-persistence.test.ts

@@ -43,6 +43,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   provenanceFromTrustContext: () => ({}),
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-disk-view.js", () => ({
@@ -120,20 +121,17 @@ describe("PR 16 — Slack DM persistence parity", () => {
     // ingress handler builds a `slackInbound` with no `threadTs` and threads
     // it through to persistence.
     const ctx = createSlackTurnContext();
-    await persistQueuedMessageBody(
-      ctx,
-      "hello from DM",
-      [],
-      "req-dm",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "hello from DM",
+      requestId: "req-dm",
+      metadata: {
         slackInbound: {
           channelId: "D0123DM",
           channelTs: "1700000000.123456",
           displayName: "Alice",
         },
       },
-      undefined,
-    );
+    });
 
     const slackMeta = lastPersistedSlackMeta();
     expect(slackMeta).not.toBeNull();
@@ -157,19 +155,16 @@ describe("PR 16 — Slack DM persistence parity", () => {
     // gateway can't resolve the user). The envelope should still be written;
     // only the optional displayName field is omitted.
     const ctx = createSlackTurnContext();
-    await persistQueuedMessageBody(
-      ctx,
-      "anonymous DM",
-      [],
-      "req-dm-anon",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "anonymous DM",
+      requestId: "req-dm-anon",
+      metadata: {
         slackInbound: {
           channelId: "D9999DM",
           channelTs: "1700000000.555555",
         },
       },
-      undefined,
-    );
+    });
 
     const slackMeta = lastPersistedSlackMeta();
     expect(slackMeta).not.toBeNull();
@@ -181,12 +176,10 @@ describe("PR 16 — Slack DM persistence parity", () => {
 
   test("DM inbound persists Slack actor timezone metadata", async () => {
     const ctx = createSlackTurnContext();
-    await persistQueuedMessageBody(
-      ctx,
-      "hello across timezones",
-      [],
-      "req-dm-timezone",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "hello across timezones",
+      requestId: "req-dm-timezone",
+      metadata: {
         slackInbound: {
           channelId: "D0123DM",
           channelTs: "1700000000.777777",
@@ -199,8 +192,7 @@ describe("PR 16 — Slack DM persistence parity", () => {
           speakerTimezoneLabel: "ET",
         },
       },
-      undefined,
-    );
+    });
 
     const slackMeta = lastPersistedSlackMeta();
     expect(slackMeta).not.toBeNull();
@@ -215,12 +207,10 @@ describe("PR 16 — Slack DM persistence parity", () => {
   test("DM and channel-message envelopes differ only by threadTs", async () => {
     // Capture the channel-thread case first.
     const ctx = createSlackTurnContext();
-    await persistQueuedMessageBody(
-      ctx,
-      "channel thread reply",
-      [],
-      "req-channel",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "channel thread reply",
+      requestId: "req-channel",
+      metadata: {
         slackInbound: {
           channelId: "C0123CHAN",
           channelTs: "1700000000.999999",
@@ -228,8 +218,7 @@ describe("PR 16 — Slack DM persistence parity", () => {
           displayName: "Bob",
         },
       },
-      undefined,
-    );
+    });
     const channelMeta = lastPersistedSlackMeta();
     expect(channelMeta).not.toBeNull();
     expect(channelMeta!.threadTs).toBe("1700000000.111111");
@@ -237,20 +226,17 @@ describe("PR 16 — Slack DM persistence parity", () => {
     // Now dispatch a DM and assert that every shared field has the same
     // shape — only `threadTs` (and the inputs themselves) differ.
     addMessageCalls.length = 0;
-    await persistQueuedMessageBody(
-      ctx,
-      "DM reply",
-      [],
-      "req-dm-2",
-      {
+    await persistQueuedMessageBody(ctx, {
+      content: "DM reply",
+      requestId: "req-dm-2",
+      metadata: {
         slackInbound: {
           channelId: "D9999DM",
           channelTs: "1700000000.222222",
           displayName: "Carol",
         },
       },
-      undefined,
-    );
+    });
     const dmMeta = lastPersistedSlackMeta();
     expect(dmMeta).not.toBeNull();
     expect(dmMeta!.source).toBe(channelMeta!.source);

package/src/__tests__/document-create-dedupe.test.ts

@@ -0,0 +1,189 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  getDocumentById,
+  getDocumentsForConversation,
+} from "../documents/document-store.js";
+import { getSqlite } from "../memory/db-connection.js";
+import { executeDocumentCreate } from "../tools/document/document-tool.js";
+import type { ToolContext, ToolExecutionResult } from "../tools/types.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
+
+function makeContext(overrides: Partial<ToolContext> = {}): ToolContext {
+  return {
+    workingDir: "/tmp/project",
+    conversationId: "conv-current",
+    trustClass: "trusted_contact",
+    executionChannel: "slack",
+    sendToClient: () => {},
+    ...overrides,
+  };
+}
+
+function parseResult<T>(result: ToolExecutionResult): T {
+  return JSON.parse(result.content) as T;
+}
+
+function bootstrapDocumentTables(): void {
+  resetDbForTesting();
+  const raw = getSqlite();
+  raw.exec(/*sql*/ `
+    DROP TABLE IF EXISTS document_conversations;
+    DROP TABLE IF EXISTS documents;
+    DROP TABLE IF EXISTS conversations;
+
+    CREATE TABLE conversations (
+      id TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)
+    );
+
+    CREATE TABLE documents (
+      surface_id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      word_count INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE document_conversations (
+      surface_id TEXT NOT NULL,
+      conversation_id TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      PRIMARY KEY (surface_id, conversation_id),
+      FOREIGN KEY (surface_id) REFERENCES documents(surface_id) ON DELETE CASCADE
+    );
+  `);
+}
+
+function seedDocument(params: {
+  surfaceId: string;
+  conversationId: string;
+  title: string;
+  content: string;
+  createdAt: number;
+}): void {
+  const raw = getSqlite();
+  raw
+    .query(`INSERT OR IGNORE INTO conversations (id, created_at) VALUES (?, ?)`)
+    .run(params.conversationId, params.createdAt);
+  raw
+    .query(
+      `INSERT INTO documents (surface_id, conversation_id, title, content, word_count, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(
+      params.surfaceId,
+      params.conversationId,
+      params.title,
+      params.content,
+      params.content.split(/\s+/).filter(Boolean).length,
+      params.createdAt,
+      params.createdAt,
+    );
+  raw
+    .query(
+      `INSERT OR IGNORE INTO document_conversations (surface_id, conversation_id, created_at) VALUES (?, ?, ?)`,
+    )
+    .run(params.surfaceId, params.conversationId, params.createdAt);
+}
+
+describe("executeDocumentCreate — dedupe empty same-title document", () => {
+  beforeEach(() => {
+    bootstrapDocumentTables();
+  });
+
+  test("reuses an empty same-title doc when incoming content is non-empty", () => {
+    const seededId = "doc-empty-seeded";
+    seedDocument({
+      surfaceId: seededId,
+      conversationId: "conv-current",
+      title: "My Post",
+      content: "",
+      createdAt: Date.now(),
+    });
+
+    const result = executeDocumentCreate(
+      { title: "My Post", initial_content: "Hello" },
+      makeContext(),
+    );
+    expect(result.isError).toBe(false);
+    const body = parseResult<{
+      surface_id: string;
+      reused?: boolean;
+      message?: string;
+    }>(result);
+    expect(body.surface_id).toBe(seededId);
+    expect(body.reused).toBe(true);
+    expect(body.message).toBe("Document editor reopened (deduped empty draft)");
+
+    expect(getDocumentById(seededId)?.content).toBe("Hello");
+    expect(getDocumentsForConversation("conv-current").length).toBe(1);
+  });
+
+  test("creates a new doc when incoming initial_content is empty (no dedupe)", () => {
+    const seededId = "doc-empty-seeded";
+    seedDocument({
+      surfaceId: seededId,
+      conversationId: "conv-current",
+      title: "My Post",
+      content: "",
+      createdAt: Date.now(),
+    });
+
+    const result = executeDocumentCreate(
+      { title: "My Post", initial_content: "" },
+      makeContext(),
+    );
+    expect(result.isError).toBe(false);
+    const body = parseResult<{ surface_id: string; reused?: boolean }>(result);
+    expect(body.reused).toBeUndefined();
+    expect(body.surface_id).not.toBe(seededId);
+    expect(getDocumentsForConversation("conv-current").length).toBe(2);
+  });
+
+  test("does not dedupe when the seeded doc already has content", () => {
+    const seededId = "doc-has-content";
+    seedDocument({
+      surfaceId: seededId,
+      conversationId: "conv-current",
+      title: "My Post",
+      content: "already drafted",
+      createdAt: Date.now(),
+    });
+
+    const result = executeDocumentCreate(
+      { title: "My Post", initial_content: "Hello" },
+      makeContext(),
+    );
+    expect(result.isError).toBe(false);
+    const body = parseResult<{ surface_id: string; reused?: boolean }>(result);
+    expect(body.reused).toBeUndefined();
+    expect(body.surface_id).not.toBe(seededId);
+    expect(getDocumentById(seededId)?.content).toBe("already drafted");
+    expect(getDocumentsForConversation("conv-current").length).toBe(2);
+  });
+
+  test("does not dedupe when the seeded empty doc is outside the 5-minute window", () => {
+    const seededId = "doc-stale-empty";
+    seedDocument({
+      surfaceId: seededId,
+      conversationId: "conv-current",
+      title: "My Post",
+      content: "",
+      // 10 minutes ago — outside the 5-minute dedupe window.
+      createdAt: Date.now() - 10 * 60 * 1000,
+    });
+
+    const result = executeDocumentCreate(
+      { title: "My Post", initial_content: "Hello" },
+      makeContext(),
+    );
+    expect(result.isError).toBe(false);
+    const body = parseResult<{ surface_id: string; reused?: boolean }>(result);
+    expect(body.reused).toBeUndefined();
+    expect(body.surface_id).not.toBe(seededId);
+    expect(getDocumentById(seededId)?.content).toBe("");
+    expect(getDocumentsForConversation("conv-current").length).toBe(2);
+  });
+});

package/src/__tests__/document-find-replace.test.ts

@@ -1,12 +1,13 @@
 import { beforeEach, describe, expect, test } from "bun:test";
 
 import { getDocumentById } from "../documents/document-store.js";
-import { getSqlite, resetDb } from "../memory/db-connection.js";
+import { getSqlite } from "../memory/db-connection.js";
 import {
   executeDocumentFind,
   executeDocumentReplaceText,
 } from "../tools/document/document-tool.js";
 import type { ToolContext, ToolExecutionResult } from "../tools/types.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 function makeContext(overrides: Partial<ToolContext> = {}): ToolContext {
   return {
@@ -23,7 +24,7 @@ function parseResult<T>(result: ToolExecutionResult): T {
 }
 
 function bootstrapDocumentTables(): void {
-  resetDb();
+  resetDbForTesting();
   const raw = getSqlite();
   raw.exec(/*sql*/ `
     DROP TABLE IF EXISTS document_conversations;