@vellumai/assistant 0.5.16 → 0.6.1

package/src/__tests__/rebuild-index-graph-nodes.test.ts

@@ -0,0 +1,273 @@
+/**
+ * Verifies that rebuildIndexJob enqueues embed jobs for graph nodes and
+ * semantic triggers alongside segments, summaries, and media.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Mocks ────────────────────────────────────────────────────────────
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// Track enqueued jobs
+const enqueuedJobs: Array<{ type: string; payload: Record<string, unknown> }> =
+  [];
+
+mock.module("../memory/jobs-store.js", () => ({
+  enqueueMemoryJob: (type: string, payload: Record<string, unknown>) => {
+    enqueuedJobs.push({ type, payload });
+  },
+}));
+
+// Stub config — multimodal disabled so we only test the graph path
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    memory: { enabled: true },
+  }),
+}));
+
+mock.module("../memory/embedding-backend.js", () => ({
+  selectedBackendSupportsMultimodal: async () => false,
+}));
+
+// ── In-memory SQLite ─────────────────────────────────────────────────
+
+import Database from "bun:sqlite";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import * as schema from "../memory/schema.js";
+
+let db: ReturnType<typeof drizzle>;
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  db = drizzle(sqlite, { schema });
+
+  // Create minimal tables needed by rebuildIndexJob
+  sqlite.exec(`
+    CREATE TABLE memory_embeddings (
+      id TEXT PRIMARY KEY,
+      target_type TEXT NOT NULL,
+      target_id TEXT NOT NULL,
+      provider TEXT NOT NULL,
+      model TEXT NOT NULL,
+      dimensions INTEGER NOT NULL,
+      vector_blob BLOB,
+      vector_json TEXT,
+      content_hash TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE memory_summaries (
+      id TEXT PRIMARY KEY
+    );
+
+    CREATE TABLE memory_segments (
+      id TEXT PRIMARY KEY
+    );
+
+    CREATE TABLE messages (
+      id TEXT PRIMARY KEY,
+      content TEXT NOT NULL
+    );
+
+    CREATE TABLE media_assets (
+      id TEXT PRIMARY KEY,
+      status TEXT NOT NULL
+    );
+
+    CREATE TABLE memory_graph_nodes (
+      id TEXT PRIMARY KEY,
+      content TEXT NOT NULL,
+      type TEXT NOT NULL,
+      created INTEGER NOT NULL,
+      last_accessed INTEGER NOT NULL,
+      last_consolidated INTEGER NOT NULL,
+      emotional_charge TEXT NOT NULL,
+      fidelity TEXT NOT NULL DEFAULT 'vivid',
+      confidence REAL NOT NULL,
+      significance REAL NOT NULL,
+      stability REAL NOT NULL DEFAULT 14,
+      reinforcement_count INTEGER NOT NULL DEFAULT 0,
+      last_reinforced INTEGER NOT NULL,
+      source_conversations TEXT NOT NULL DEFAULT '[]',
+      source_type TEXT NOT NULL DEFAULT 'inferred',
+      narrative_role TEXT,
+      part_of_story TEXT,
+      scope_id TEXT NOT NULL DEFAULT 'default',
+      event_date INTEGER,
+      image_refs TEXT
+    );
+
+    CREATE TABLE memory_graph_triggers (
+      id TEXT PRIMARY KEY,
+      node_id TEXT NOT NULL,
+      type TEXT NOT NULL,
+      schedule TEXT,
+      condition TEXT,
+      condition_embedding BLOB,
+      threshold REAL,
+      event_date INTEGER,
+      ramp_days INTEGER,
+      follow_up_days INTEGER,
+      recurring INTEGER NOT NULL DEFAULT 0,
+      consumed INTEGER NOT NULL DEFAULT 0,
+      cooldown_ms INTEGER,
+      last_fired INTEGER
+    );
+  `);
+
+  return { sqlite, db };
+}
+
+mock.module("../memory/db.js", () => ({
+  getDb: () => db,
+}));
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+import { rebuildIndexJob } from "../memory/job-handlers/index-maintenance.js";
+
+describe("rebuildIndexJob", () => {
+  beforeEach(() => {
+    enqueuedJobs.length = 0;
+    createTestDb();
+  });
+
+  test("enqueues embed_graph_node jobs for non-gone graph nodes", async () => {
+    const now = Date.now();
+    const charge = JSON.stringify({
+      valence: 0,
+      intensity: 0.1,
+      decayCurve: "linear",
+      decayRate: 0.05,
+      originalIntensity: 0.1,
+    });
+
+    // Insert two vivid nodes and one gone node
+    db.insert(schema.memoryGraphNodes)
+      .values([
+        {
+          id: "node-1",
+          content: "User likes hiking",
+          type: "semantic",
+          created: now,
+          lastAccessed: now,
+          lastConsolidated: now,
+          emotionalCharge: charge,
+          fidelity: "vivid",
+          confidence: 0.9,
+          significance: 0.8,
+          stability: 14,
+          reinforcementCount: 0,
+          lastReinforced: now,
+          scopeId: "default",
+        },
+        {
+          id: "node-2",
+          content: "User works remotely",
+          type: "semantic",
+          created: now,
+          lastAccessed: now,
+          lastConsolidated: now,
+          emotionalCharge: charge,
+          fidelity: "clear",
+          confidence: 0.85,
+          significance: 0.7,
+          stability: 14,
+          reinforcementCount: 0,
+          lastReinforced: now,
+          scopeId: "default",
+        },
+        {
+          id: "node-gone",
+          content: "Decayed memory",
+          type: "semantic",
+          created: now,
+          lastAccessed: now,
+          lastConsolidated: now,
+          emotionalCharge: charge,
+          fidelity: "gone",
+          confidence: 0.1,
+          significance: 0.1,
+          stability: 1,
+          reinforcementCount: 0,
+          lastReinforced: now,
+          scopeId: "default",
+        },
+      ])
+      .run();
+
+    await rebuildIndexJob();
+
+    const graphJobs = enqueuedJobs.filter((j) => j.type === "embed_graph_node");
+    expect(graphJobs).toHaveLength(2);
+    expect(graphJobs.map((j) => j.payload.nodeId).sort()).toEqual([
+      "node-1",
+      "node-2",
+    ]);
+  });
+
+  test("enqueues graph_trigger_embed jobs for triggers with conditions", async () => {
+    const now = Date.now();
+    const charge = JSON.stringify({
+      valence: 0,
+      intensity: 0.1,
+      decayCurve: "linear",
+      decayRate: 0.05,
+      originalIntensity: 0.1,
+    });
+
+    // Need a node for the trigger FK
+    db.insert(schema.memoryGraphNodes)
+      .values({
+        id: "node-t",
+        content: "Trigger parent",
+        type: "semantic",
+        created: now,
+        lastAccessed: now,
+        lastConsolidated: now,
+        emotionalCharge: charge,
+        fidelity: "vivid",
+        confidence: 0.9,
+        significance: 0.8,
+        stability: 14,
+        reinforcementCount: 0,
+        lastReinforced: now,
+        scopeId: "default",
+      })
+      .run();
+
+    db.insert(schema.memoryGraphTriggers)
+      .values([
+        {
+          id: "trig-1",
+          nodeId: "node-t",
+          type: "semantic",
+          condition: "when user mentions hiking",
+        },
+        {
+          id: "trig-2",
+          nodeId: "node-t",
+          type: "temporal",
+          schedule: "0 9 * * *",
+          condition: null,
+        },
+      ])
+      .run();
+
+    await rebuildIndexJob();
+
+    const triggerJobs = enqueuedJobs.filter(
+      (j) => j.type === "graph_trigger_embed",
+    );
+    expect(triggerJobs).toHaveLength(1);
+    expect(triggerJobs[0].payload.triggerId).toBe("trig-1");
+  });
+});

package/src/__tests__/registry.test.ts

@@ -109,13 +109,13 @@ describe("tool registry dynamic-tools tools", () => {
 
 describe("tool manifest", () => {
   test("eager module tool names list contains expected count", () => {
-    expect(eagerModuleToolNames.length).toBe(9);
+    expect(eagerModuleToolNames.length).toBe(11);
   });
 
   test("explicit tools list includes memory and credential tools", () => {
     const names = explicitTools.map((t) => t.name);
-    expect(names).toContain("memory_recall");
-    expect(names).toContain("memory_manage");
+    expect(names).toContain("recall");
+    expect(names).toContain("remember");
     expect(names).toContain("credential_store");
     // start_screen_watch moved to the screen-watch bundled skill
     expect(names).not.toContain("start_screen_watch");

package/src/__tests__/require-fresh-approval.test.ts

@@ -20,7 +20,7 @@ import {
   test,
 } from "bun:test";
 
-import type { ScopeOption } from "../permissions/types.js";
+import { RiskLevel, type ScopeOption } from "../permissions/types.js";
 import type {
   ToolExecutionResult,
   ToolLifecycleEvent,
@@ -68,6 +68,9 @@ let fakeToolResult: ToolExecutionResult = { content: "ok", isError: false };
 /** Override the check() result for specific tests. */
 let checkResultOverride: { decision: string; reason: string } | undefined;
 
+/** Override the risk level returned by classifyRisk(). Defaults to "high". */
+let riskOverride: string = "high";
+
 /** Scope options override — controls whether persistent decisions are offered. */
 let scopeOptionsOverride: ScopeOption[] | undefined;
 
@@ -91,7 +94,7 @@ mock.module("../util/logger.js", () => ({
 }));
 
 mock.module("../permissions/checker.js", () => ({
-  classifyRisk: async () => "high",
+  classifyRisk: async () => riskOverride,
   check: async () => {
     if (checkResultOverride) return checkResultOverride;
     return { decision: "allow", reason: "allowed" };
@@ -172,6 +175,7 @@ describe("requireFreshApproval: non-interactive guardian denial", () => {
     fakeToolResult = { content: "ok", isError: false };
     checkResultOverride = undefined;
     scopeOptionsOverride = undefined;
+    riskOverride = "high";
     clearAllOverrides();
   });
 
@@ -200,6 +204,8 @@ describe("requireFreshApproval: non-interactive guardian denial", () => {
 
   test("regular tools are still auto-approved in non-interactive guardian sessions", async () => {
     // Verify that the auto-approve path still works for normal tools
+    // at non-high risk levels
+    riskOverride = RiskLevel.Medium;
     checkResultOverride = {
       decision: "prompt",
       reason: "Needs approval",
@@ -215,6 +221,58 @@ describe("requireFreshApproval: non-interactive guardian denial", () => {
     // Regular tools should be auto-approved
     expect(result.isError).toBe(false);
   });
+
+  test("high-risk tools are denied in non-interactive guardian sessions", async () => {
+    riskOverride = RiskLevel.High;
+    checkResultOverride = {
+      decision: "prompt",
+      reason: "Needs approval",
+    };
+
+    const executor = new ToolExecutor(makePrompter());
+    const result = await executor.execute(
+      "bash",
+      { command: "echo hello" },
+      makeContext({ isInteractive: false, trustClass: "guardian" }),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("requires user approval");
+  });
+
+  test("medium-risk tools are still auto-approved in non-interactive guardian sessions", async () => {
+    riskOverride = RiskLevel.Medium;
+    checkResultOverride = {
+      decision: "prompt",
+      reason: "Needs approval",
+    };
+
+    const executor = new ToolExecutor(makePrompter());
+    const result = await executor.execute(
+      "bash",
+      { command: "echo hello" },
+      makeContext({ isInteractive: false, trustClass: "guardian" }),
+    );
+
+    expect(result.isError).toBe(false);
+  });
+
+  test("low-risk tools are still auto-approved in non-interactive guardian sessions", async () => {
+    riskOverride = RiskLevel.Low;
+    checkResultOverride = {
+      decision: "prompt",
+      reason: "Needs approval",
+    };
+
+    const executor = new ToolExecutor(makePrompter());
+    const result = await executor.execute(
+      "bash",
+      { command: "echo hello" },
+      makeContext({ isInteractive: false, trustClass: "guardian" }),
+    );
+
+    expect(result.isError).toBe(false);
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -226,6 +284,7 @@ describe("requireFreshApproval: temporary override bypass", () => {
     fakeToolResult = { content: "ok", isError: false };
     checkResultOverride = undefined;
     scopeOptionsOverride = undefined;
+    riskOverride = "high";
     clearAllOverrides();
   });
 
@@ -335,6 +394,7 @@ describe("requireFreshApproval: persistent decisions disabled", () => {
     fakeToolResult = { content: "ok", isError: false };
     checkResultOverride = undefined;
     scopeOptionsOverride = undefined;
+    riskOverride = "high";
     clearAllOverrides();
   });
 
@@ -437,6 +497,7 @@ describe("requireFreshApproval: grant-consumed does not skip permission check",
     fakeToolResult = { content: "ok", isError: false };
     checkResultOverride = undefined;
     scopeOptionsOverride = undefined;
+    riskOverride = "high";
     clearAllOverrides();
   });
 
@@ -491,6 +552,7 @@ describe("requireFreshApproval: context flag propagation", () => {
     fakeToolResult = { content: "ok", isError: false };
     checkResultOverride = undefined;
     scopeOptionsOverride = undefined;
+    riskOverride = "high";
     clearAllOverrides();
   });
 

package/src/__tests__/runtime-events-sse-parity.test.ts

@@ -15,7 +15,7 @@
  *   - generation_handoff (terminal)
  *   - generation_cancelled (terminal)
  */
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -38,17 +38,13 @@ mock.module("../config/loader.js", () => ({
 
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import { getOrCreateConversation } from "../memory/conversation-key-store.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getDb, initializeDb } from "../memory/db.js";
 import type { AssistantEvent } from "../runtime/assistant-event.js";
 import { buildAssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 
 initializeDb();
 
-afterAll(() => {
-  resetDb();
-});
-
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------

package/src/__tests__/runtime-events-sse.test.ts

@@ -7,7 +7,7 @@
  *   - Happy path: stream receives a published AssistantEvent
  *   - Unfiltered: streams events from multiple conversations
  */
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -29,7 +29,7 @@ mock.module("../config/loader.js", () => ({
 }));
 
 import { getOrCreateConversation } from "../memory/conversation-key-store.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getDb, initializeDb } from "../memory/db.js";
 import { buildAssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { mintToken } from "../runtime/auth/token-service.js";
@@ -56,10 +56,6 @@ describe("SSE assistant-events endpoint", () => {
     db.run("DELETE FROM conversations");
   });
 
-  afterAll(() => {
-    resetDb();
-  });
-
   async function startServer(): Promise<void> {
     port = 19500 + Math.floor(Math.random() * 500);
     server = new RuntimeHttpServer({ port });

package/src/__tests__/sandbox-host-parity.test.ts

@@ -705,10 +705,11 @@ describe("Terminal output format: formatShellOutput shared by sandbox and host",
     const longOutput = "x".repeat(MAX_OUTPUT_LENGTH + 100);
     const result = formatShellOutput(longOutput, "", 0, false, 120);
 
-    expect(result.content.length).toBe(
-      MAX_OUTPUT_LENGTH + 1 + '<output_truncated limit="50K" />'.length,
-    );
-    expect(result.content).toContain("<output_truncated");
+    expect(result.content).toContain('limit="20K"');
+    expect(result.content).toContain('file="');
+    // The <output_truncated tag starts right after MAX_OUTPUT_LENGTH chars + 1 newline
+    const tagStart = result.content.indexOf("<output_truncated");
+    expect(tagStart).toBe(MAX_OUTPUT_LENGTH + 1);
   });
 
   test("timed-out command appends timeout tag and sets isError", () => {

package/src/__tests__/schedule-store.test.ts

@@ -1,4 +1,4 @@
-import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+import { beforeEach, describe, expect, test } from "bun:test";
 import { mock } from "bun:test";
 
 mock.module("../util/logger.js", () => ({
@@ -9,7 +9,7 @@ mock.module("../util/logger.js", () => ({
   truncateForLog: (value: string) => value,
 }));
 
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getDb, initializeDb } from "../memory/db.js";
 import {
   cancelSchedule,
   claimDueSchedules,
@@ -30,10 +30,6 @@ function getRawDb(): import("bun:sqlite").Database {
     .$client;
 }
 
-afterAll(() => {
-  resetDb();
-});
-
 // ── Cron schedules ──────────────────────────────────────────────────
 
 describe("createSchedule (cron)", () => {

package/src/__tests__/schedule-tools.test.ts

@@ -1,4 +1,4 @@
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -16,7 +16,7 @@ mock.module("../config/loader.js", () => ({
 
 import type { Database } from "bun:sqlite";
 
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getDb, initializeDb } from "../memory/db.js";
 import { executeScheduleCreate } from "../tools/schedule/create.js";
 import { executeScheduleDelete } from "../tools/schedule/delete.js";
 import { executeScheduleList } from "../tools/schedule/list.js";
@@ -25,10 +25,6 @@ import type { ToolContext } from "../tools/types.js";
 
 initializeDb();
 
-afterAll(() => {
-  resetDb();
-});
-
 function getRawDb(): Database {
   return (getDb() as unknown as { $client: Database }).$client;
 }

package/src/__tests__/scheduler-recurrence.test.ts

@@ -16,7 +16,7 @@ mock.module("../util/logger.js", () => ({
   truncateForLog: (value: string) => value,
 }));
 
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getDb, initializeDb } from "../memory/db.js";
 import {
   createSchedule,
   getSchedule,
@@ -41,10 +41,6 @@ function forceScheduleDue(scheduleId: string): void {
   ]);
 }
 
-afterAll(() => {
-  resetDb();
-});
-
 // Build an RRULE expression anchored at the given start date, recurring every minute.
 // This ensures the rule always has future occurrences relative to the test clock.
 function buildEveryMinuteRrule(dtstart: Date = new Date()): string {