@vellumai/assistant 0.7.2 → 0.8.0

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

@@ -0,0 +1,224 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
+import {
+  applyRuntimeInjections,
+  stripInjectionsForCompaction,
+} from "../daemon/conversation-runtime-assembly.js";
+import {
+  DEFAULT_INJECTOR_ORDER,
+  defaultInjectorsPlugin,
+  DISK_PRESSURE_WARNING_PROMPT,
+} from "../plugins/defaults/injectors.js";
+import {
+  registerPlugin,
+  resetPluginRegistryForTests,
+} from "../plugins/registry.js";
+import type { Injector, TurnContext } from "../plugins/types.js";
+import type { Message } from "../providers/types.js";
+
+function findInjector(name: string): Injector {
+  const injector = defaultInjectorsPlugin.injectors?.find(
+    (candidate) => candidate.name === name,
+  );
+  if (!injector) {
+    throw new Error(`injector '${name}' not registered`);
+  }
+  return injector;
+}
+
+function makeContext(overrides: Partial<TurnContext> = {}): TurnContext {
+  return {
+    requestId: "req-test",
+    conversationId: "conv-test",
+    turnIndex: 0,
+    trust: { sourceChannel: "vellum", trustClass: "guardian" },
+    ...overrides,
+  };
+}
+
+function tailTexts(messages: Message[]): string[] {
+  const tail = messages[messages.length - 1];
+  if (!tail || tail.role !== "user") return [];
+  return tail.content
+    .filter((block): block is { type: "text"; text: string } => {
+      return block.type === "text";
+    })
+    .map((block) => block.text);
+}
+
+const diskPressureInjector = findInjector("disk-pressure-warning");
+const cleanupContext = { cleanupModeActive: true };
+
+describe("disk-pressure-warning injector", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+    registerPlugin(defaultInjectorsPlugin);
+    _setOverridesForTesting({ "safe-storage-limits": true });
+  });
+
+  test("emits the exact cleanup prompt while safe storage limits are enabled", async () => {
+    const block = await diskPressureInjector.produce(
+      makeContext({
+        injectionInputs: { diskPressureContext: cleanupContext },
+      }),
+    );
+
+    expect(block).toEqual({
+      id: "disk-pressure-warning",
+      text: DISK_PRESSURE_WARNING_PROMPT,
+      placement: "prepend-user-tail",
+    });
+    expect(diskPressureInjector.order).toBe(
+      DEFAULT_INJECTOR_ORDER.diskPressureWarning,
+    );
+    expect(DISK_PRESSURE_WARNING_PROMPT).toBe(`<disk_pressure_warning>
+Disk usage is critically low: this assistant is in storage cleanup mode because the workspace volume is at least 95% full.
+
+In your first paragraph, warn the user that storage is critically low and that normal work is suspended until space is freed.
+
+Then help the user clean up storage. Prefer safe inspection steps first, such as checking available space and finding large directories. Ask before deleting files or caches unless the user has already clearly approved the specific cleanup action.
+
+Do not work on unrelated tasks until disk usage drops below the critical threshold or the user explicitly overrides the lock. Background processes and messages from trusted contacts are blocked while this cleanup mode is active.
+</disk_pressure_warning>`);
+  });
+
+  test("omits the prompt when cleanup context is null or inactive", async () => {
+    await expect(
+      diskPressureInjector.produce(
+        makeContext({ injectionInputs: { diskPressureContext: null } }),
+      ),
+    ).resolves.toBeNull();
+
+    await expect(
+      diskPressureInjector.produce(
+        makeContext({
+          injectionInputs: {
+            diskPressureContext: { cleanupModeActive: false },
+          },
+        }),
+      ),
+    ).resolves.toBeNull();
+  });
+
+  test("omits the prompt when safe storage limits are disabled", async () => {
+    _setOverridesForTesting({ "safe-storage-limits": false });
+
+    await expect(
+      diskPressureInjector.produce(
+        makeContext({
+          injectionInputs: { diskPressureContext: cleanupContext },
+        }),
+      ),
+    ).resolves.toBeNull();
+  });
+
+  test("prepends ahead of workspace and unified turn context in full mode", async () => {
+    const runMessages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "clean up space" }] },
+    ];
+    const workspace = "<workspace>\nRoot: /workspace\n</workspace>";
+    const turnContext = "<turn_context>\ninterface: macos\n</turn_context>";
+
+    const result = await applyRuntimeInjections(runMessages, {
+      turnContext: makeContext(),
+      diskPressureContext: cleanupContext,
+      workspaceTopLevelContext: workspace,
+      unifiedTurnContext: turnContext,
+    });
+
+    expect(tailTexts(result.messages).slice(0, 4)).toEqual([
+      DISK_PRESSURE_WARNING_PROMPT,
+      workspace,
+      turnContext,
+      "clean up space",
+    ]);
+    expect(
+      result.blocks.injectorChainBlock?.startsWith(
+        DISK_PRESSURE_WARNING_PROMPT,
+      ),
+    ).toBe(true);
+  });
+
+  test("survives minimal mode as safety-critical context", async () => {
+    const result = await applyRuntimeInjections(
+      [{ role: "user", content: [{ type: "text", text: "status" }] }],
+      {
+        turnContext: makeContext(),
+        mode: "minimal",
+        diskPressureContext: cleanupContext,
+        workspaceTopLevelContext: "<workspace>...</workspace>",
+        unifiedTurnContext: "<turn_context>...</turn_context>",
+      },
+    );
+
+    expect(tailTexts(result.messages)).toEqual([
+      DISK_PRESSURE_WARNING_PROMPT,
+      "<turn_context>...</turn_context>",
+      "status",
+    ]);
+  });
+
+  test("applies after Slack chronological transcript replacement", async () => {
+    const originalRun: Message[] = [
+      {
+        role: "user",
+        content: [{ type: "text", text: "latest raw user text" }],
+      },
+    ];
+    const slackTranscript: Message[] = [
+      {
+        role: "user",
+        content: [{ type: "text", text: "[12:00 user]: earlier" }],
+      },
+      {
+        role: "user",
+        content: [{ type: "text", text: "[12:01 @assistant]: cleanup?" }],
+      },
+    ];
+
+    const result = await applyRuntimeInjections(originalRun, {
+      turnContext: makeContext(),
+      diskPressureContext: cleanupContext,
+      channelCapabilities: {
+        channel: "slack",
+        dashboardCapable: false,
+        supportsDynamicUi: false,
+        supportsVoiceInput: false,
+        chatType: "channel",
+      },
+      slackChronologicalMessages: slackTranscript,
+    });
+
+    expect(result.messages).toHaveLength(2);
+    const texts = tailTexts(result.messages);
+    expect(texts[0]).toBe(DISK_PRESSURE_WARNING_PROMPT);
+    expect(
+      texts.some((text) => text.startsWith("<channel_capabilities>")),
+    ).toBe(true);
+    expect(texts[texts.length - 1]).toBe("[12:01 @assistant]: cleanup?");
+  });
+
+  test("compaction strip plus re-apply does not duplicate the warning", async () => {
+    const runMessages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "find large files" }] },
+    ];
+
+    const first = await applyRuntimeInjections(runMessages, {
+      turnContext: makeContext(),
+      diskPressureContext: cleanupContext,
+    });
+    const stripped = stripInjectionsForCompaction(first.messages);
+    expect(tailTexts(stripped)).toEqual(["find large files"]);
+
+    const second = await applyRuntimeInjections(stripped, {
+      turnContext: makeContext(),
+      diskPressureContext: cleanupContext,
+    });
+    expect(
+      tailTexts(second.messages).filter(
+        (text) => text === DISK_PRESSURE_WARNING_PROMPT,
+      ),
+    ).toHaveLength(1);
+  });
+});

package/src/__tests__/injector-pkb-v2-silenced.test.ts

@@ -1,23 +1,26 @@
 /**
  * v2 read-side cutover behavior for the PKB-derived default injectors.
  *
- * When `isMemoryV2ReadActive(getConfig())` is true:
+ * When `getConfig().memory.v2.enabled` is true:
  *   - `pkb-context` silences itself (concept pages own retrieval).
  *   - `pkb-reminder` still fires (its body is generic recall/remember
  *     guidance) but skips the PKB-search hints — those name PKB paths.
  *   - `now-md` fires unchanged (workspace state, independent of PKB).
  *
- * Mocks `isMemoryV2ReadActive` at the module level so each test can flip the
- * effective gate state without standing up a full feature-flag + config
- * stack. Mocks the PKB hybrid search so the reminder-with-hints branch can
- * resolve deterministically when called.
+ * Mocks `getConfig` at the module level so each test can flip the effective
+ * gate state without standing up a full config stack. Mocks the PKB hybrid
+ * search so the reminder-with-hints branch can resolve deterministically
+ * when called.
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 let v2Active = false;
 
-mock.module("../memory/context-search/sources/memory-v2.js", () => ({
-  isMemoryV2ReadActive: () => v2Active,
+const realLoader = await import("../config/loader.js");
+
+mock.module("../config/loader.js", () => ({
+  ...realLoader,
+  getConfig: () => ({ memory: { v2: { enabled: v2Active } } }),
 }));
 
 mock.module("../memory/pkb/pkb-search.js", () => ({

package/src/__tests__/lifecycle-memory-v2-seed.test.ts

@@ -1,17 +1,17 @@
 /**
- * Tests for the memory-v2 skill seed gate invoked from the daemon startup
- * path (`assistant/src/daemon/memory-v2-startup.ts`).
+ * Tests for the memory-v2 skill seed gate and the v2 concept-page schema
+ * rebuild gate, both invoked from the daemon startup path
+ * (`assistant/src/daemon/memory-v2-startup.ts`).
  *
- * The gate is exercised in isolation rather than mounting the full lifecycle
- * import graph. Coverage matrix from PR 8 acceptance criteria:
- *   - Case 1: feature flag on + `config.memory.v2.enabled` on → seed runs.
- *   - Case 2: feature flag off → seed does not run.
- *   - Case 3: `config.memory.v2.enabled` off (flag on) → seed does not run.
- *   - Case 4: `seedV2SkillEntries` rejects → gate does not throw and the
- *     warning is logged.
+ * The gates are exercised in isolation rather than mounting the full
+ * lifecycle import graph. Coverage matrix:
+ *   - Skill seed (`maybeSeedMemoryV2Skills`): config gating, rejection
+ *     swallowing.
+ *   - Schema rebuild (`maybeRebuildMemoryV2Concepts`): config gating,
+ *     drift-triggered reembed enqueue, empty-after-create reembed enqueue,
+ *     no enqueue when collection is healthy, error swallowing.
  *
- * The seed call itself is fire-and-forget (`void` + `.catch`); the gate must
- * never block startup or surface an exception.
+ * Both gates must never block startup or surface an exception.
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -22,31 +22,36 @@ import type { AssistantConfig } from "../config/schema.js";
 // ---------------------------------------------------------------------------
 
 interface TestState {
-  flagOverrides: Record<string, boolean>;
   seedCallCount: number;
   seedShouldReject: Error | null;
   warnCalls: Array<{ obj: unknown; msg: unknown }>;
+  infoCalls: Array<{ obj: unknown; msg: unknown }>;
+  // Rebuild-gate mocks (drive maybeRebuildMemoryV2Concepts).
+  ensureCollectionCallCount: number;
+  ensureCollectionResult: { migrated: boolean };
+  ensureCollectionThrows: Error | null;
+  countResult: number;
+  listPagesResult: string[];
+  enqueueCalls: Array<{ type: string; payload: Record<string, unknown> }>;
 }
 
 const state: TestState = {
-  flagOverrides: {},
   seedCallCount: 0,
   seedShouldReject: null,
   warnCalls: [],
+  infoCalls: [],
+  ensureCollectionCallCount: 0,
+  ensureCollectionResult: { migrated: false },
+  ensureCollectionThrows: null,
+  countResult: 0,
+  listPagesResult: [],
+  enqueueCalls: [],
 };
 
 // ---------------------------------------------------------------------------
 // Mocks — installed before the module under test is loaded.
 // ---------------------------------------------------------------------------
 
-mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: (key: string, _config: unknown): boolean => {
-    const explicit = state.flagOverrides[key];
-    if (typeof explicit === "boolean") return explicit;
-    return true; // undeclared flags default to enabled
-  },
-}));
-
 mock.module("../memory/v2/skill-store.js", () => ({
   seedV2SkillEntries: async (): Promise<void> => {
     state.seedCallCount += 1;
@@ -54,18 +59,51 @@ mock.module("../memory/v2/skill-store.js", () => ({
   },
 }));
 
+mock.module("../memory/v2/qdrant.js", () => ({
+  ensureConceptPageCollection: async (): Promise<{ migrated: boolean }> => {
+    state.ensureCollectionCallCount += 1;
+    if (state.ensureCollectionThrows) throw state.ensureCollectionThrows;
+    return state.ensureCollectionResult;
+  },
+  countConceptPagePoints: async (): Promise<number> => state.countResult,
+  // The rebuild gate does not call this, but the seed gate's fire-and-forget
+  // chain imports it; provide a no-op so the dynamic import resolves.
+  dropLegacySkillsCollection: async (): Promise<void> => {},
+}));
+
+mock.module("../memory/v2/page-store.js", () => ({
+  hasConceptPages: async (): Promise<boolean> =>
+    state.listPagesResult.length > 0,
+}));
+
+mock.module("../memory/jobs-store.js", () => ({
+  enqueueMemoryJob: (
+    type: string,
+    payload: Record<string, unknown>,
+  ): string => {
+    state.enqueueCalls.push({ type, payload });
+    return "test-job-id";
+  },
+}));
+
+mock.module("../util/platform.js", () => ({
+  getWorkspaceDir: () => "/tmp/test-workspace",
+}));
+
 mock.module("../util/logger.js", () => ({
   getLogger: () => ({
     warn: (obj: unknown, msg: unknown) => {
       state.warnCalls.push({ obj, msg });
     },
-    info: () => {},
+    info: (obj: unknown, msg: unknown) => {
+      state.infoCalls.push({ obj, msg });
+    },
     error: () => {},
     debug: () => {},
   }),
 }));
 
-const { maybeSeedMemoryV2Skills } =
+const { maybeSeedMemoryV2Skills, maybeRebuildMemoryV2Concepts } =
   await import("../daemon/memory-v2-startup.js");
 
 // ---------------------------------------------------------------------------
@@ -99,65 +137,37 @@ async function flushMicrotasks(): Promise<void> {
 // Tests
 // ---------------------------------------------------------------------------
 
+function resetState(): void {
+  state.seedCallCount = 0;
+  state.seedShouldReject = null;
+  state.warnCalls = [];
+  state.infoCalls = [];
+  state.ensureCollectionCallCount = 0;
+  state.ensureCollectionResult = { migrated: false };
+  state.ensureCollectionThrows = null;
+  state.countResult = 0;
+  state.listPagesResult = [];
+  state.enqueueCalls = [];
+}
+
 describe("maybeSeedMemoryV2Skills (daemon startup gate)", () => {
-  beforeEach(() => {
-    state.flagOverrides = {};
-    state.seedCallCount = 0;
-    state.seedShouldReject = null;
-    state.warnCalls = [];
-  });
+  beforeEach(resetState);
 
-  test("invokes seedV2SkillEntries when flag and config are both enabled", async () => {
-    state.flagOverrides = { "memory-v2-enabled": true };
+  test("invokes seedV2SkillEntries when memory.v2.enabled is true", async () => {
     maybeSeedMemoryV2Skills(makeConfig(true));
     await flushMicrotasks();
     expect(state.seedCallCount).toBe(1);
     expect(state.warnCalls).toHaveLength(0);
   });
 
-  test("does not invoke seedV2SkillEntries when feature flag is off", async () => {
-    state.flagOverrides = { "memory-v2-enabled": false };
-    maybeSeedMemoryV2Skills(makeConfig(true));
-    await flushMicrotasks();
-    expect(state.seedCallCount).toBe(0);
-    expect(state.warnCalls).toHaveLength(0);
-  });
-
-  test("does not invoke seedV2SkillEntries when config.memory.v2.enabled is off", async () => {
-    state.flagOverrides = { "memory-v2-enabled": true };
-    maybeSeedMemoryV2Skills(makeConfig(false));
-    await flushMicrotasks();
-    expect(state.seedCallCount).toBe(0);
-    expect(state.warnCalls).toHaveLength(0);
-  });
-
-  test("does not invoke seedV2SkillEntries when both gates are off", async () => {
-    state.flagOverrides = { "memory-v2-enabled": false };
+  test("does not invoke seedV2SkillEntries when memory.v2.enabled is false", async () => {
     maybeSeedMemoryV2Skills(makeConfig(false));
     await flushMicrotasks();
     expect(state.seedCallCount).toBe(0);
     expect(state.warnCalls).toHaveLength(0);
   });
 
-  test("re-invocation seeds after flag flips on (deferred-init race recovery)", async () => {
-    // Models the lifecycle-startup race: the synchronous seed call evaluates
-    // the flag while the gateway IPC override fetch is still in flight, falls
-    // through to the registry default (`false`), and skips. Once
-    // `initFeatureFlagOverrides()` resolves, the chained `.then` re-invokes
-    // the seed with the now-populated cache and the flag flips to `true`.
-    state.flagOverrides = { "memory-v2-enabled": false };
-    maybeSeedMemoryV2Skills(makeConfig(true));
-    await flushMicrotasks();
-    expect(state.seedCallCount).toBe(0);
-
-    state.flagOverrides = { "memory-v2-enabled": true };
-    maybeSeedMemoryV2Skills(makeConfig(true));
-    await flushMicrotasks();
-    expect(state.seedCallCount).toBe(1);
-  });
-
   test("swallows seedV2SkillEntries rejections and logs a warning", async () => {
-    state.flagOverrides = { "memory-v2-enabled": true };
     state.seedShouldReject = new Error("seed failed");
 
     // The gate must not throw — startup must not block on this.
@@ -172,3 +182,80 @@ describe("maybeSeedMemoryV2Skills (daemon startup gate)", () => {
     expect(msg).toBe("Failed to seed v2 skill entries");
   });
 });
+
+describe("maybeRebuildMemoryV2Concepts (daemon startup gate)", () => {
+  beforeEach(resetState);
+
+  test("does nothing when memory.v2.enabled is false", async () => {
+    await maybeRebuildMemoryV2Concepts(makeConfig(false));
+
+    expect(state.ensureCollectionCallCount).toBe(0);
+    expect(state.enqueueCalls).toEqual([]);
+  });
+
+  test("enqueues memory_v2_reembed when the collection was migrated", async () => {
+    state.ensureCollectionResult = { migrated: true };
+
+    await maybeRebuildMemoryV2Concepts(makeConfig(true));
+
+    expect(state.ensureCollectionCallCount).toBe(1);
+    expect(state.enqueueCalls).toEqual([
+      { type: "memory_v2_reembed", payload: {} },
+    ]);
+    // Migrated path skips the count probe — drift detection is the trigger.
+    // (The mock's countConceptPagePoints would silently return 0 either way,
+    // but keeping the path conditional keeps the lifecycle hook predictable.)
+  });
+
+  test("enqueues reembed when the collection is empty but pages exist on disk (crash-mid-rebuild recovery)", async () => {
+    state.ensureCollectionResult = { migrated: false };
+    state.countResult = 0;
+    state.listPagesResult = ["people/alice", "topics/zsh"];
+
+    await maybeRebuildMemoryV2Concepts(makeConfig(true));
+
+    expect(state.enqueueCalls).toEqual([
+      { type: "memory_v2_reembed", payload: {} },
+    ]);
+  });
+
+  test("does not enqueue when the collection is healthy and populated", async () => {
+    state.ensureCollectionResult = { migrated: false };
+    state.countResult = 1185;
+    state.listPagesResult = ["people/alice"];
+
+    await maybeRebuildMemoryV2Concepts(makeConfig(true));
+
+    expect(state.enqueueCalls).toEqual([]);
+  });
+
+  test("does not enqueue when the collection is empty AND no pages exist on disk (fresh workspace)", async () => {
+    state.ensureCollectionResult = { migrated: false };
+    state.countResult = 0;
+    state.listPagesResult = [];
+
+    await maybeRebuildMemoryV2Concepts(makeConfig(true));
+
+    expect(state.enqueueCalls).toEqual([]);
+  });
+
+  test("swallows ensureConceptPageCollection failures and logs a warning", async () => {
+    state.ensureCollectionThrows = new Error("Qdrant unreachable");
+
+    // Must not throw — startup never blocks on this gate.
+    let thrown: unknown = null;
+    try {
+      await maybeRebuildMemoryV2Concepts(makeConfig(true));
+    } catch (err) {
+      thrown = err;
+    }
+    expect(thrown).toBeNull();
+
+    expect(state.enqueueCalls).toEqual([]);
+    expect(state.warnCalls.length).toBeGreaterThan(0);
+    const lastWarn = state.warnCalls[state.warnCalls.length - 1];
+    expect((lastWarn.obj as { err: Error }).err.message).toBe(
+      "Qdrant unreachable",
+    );
+  });
+});

package/src/__tests__/managed-profile-guard.test.ts

@@ -125,6 +125,16 @@ describe("PUT /v1/config/llm/profiles/:name — managed profile guard", () => {
     ).toThrow(BadRequestError);
   });
 
+  test("allows edits to custom-balanced (user-owned)", () => {
+    savedRaw = null;
+    const result = replaceRoute.handler({
+      pathParams: { name: "custom-balanced" },
+      body: { provider: "openai", model: "gpt-4o" },
+    });
+    expect(result).toEqual({ ok: true });
+    expect(savedRaw).not.toBeNull();
+  });
+
   test("allows edits to a user-defined profile", () => {
     savedRaw = null;
     const result = replaceRoute.handler({
@@ -165,6 +175,14 @@ describe("PATCH /v1/config — managed profile deletion guard", () => {
     ).rejects.toThrow(BadRequestError);
   });
 
+  test("allows deletion of custom-balanced via null (user-owned)", async () => {
+    savedRaw = null;
+    const result = await patchRoute.handler({
+      body: { llm: { profiles: { "custom-balanced": null } } },
+    });
+    expect(result).toEqual({ ok: true });
+  });
+
   test("allows deletion of a user-defined profile via null", async () => {
     savedRaw = null;
     const result = await patchRoute.handler({