@vellumai/assistant 0.5.16 → 0.6.0

package/src/__tests__/checker.test.ts

@@ -170,17 +170,39 @@ describe("Permission Checker", () => {
   // ── classifyRisk ────────────────────────────────────────────────
 
   describe("classifyRisk", () => {
-    // file_read is always low
+    // file_read is low risk except for signing-key material
     describe("file_read", () => {
-      test("file_read is always low risk", async () => {
+      test("file_read is low risk for regular files", async () => {
         const risk = await classifyRisk("file_read", { path: "/etc/passwd" });
         expect(risk).toBe(RiskLevel.Low);
       });
 
-      test("file_read with any path is low risk", async () => {
+      test("file_read with arbitrary non-key path is low risk", async () => {
         const risk = await classifyRisk("file_read", { path: "/tmp/safe.txt" });
         expect(risk).toBe(RiskLevel.Low);
       });
+
+      test("file_read of workspace signing key path is high risk", async () => {
+        const workspaceDir = join(checkerTestDir, "workspace");
+        const risk = await classifyRisk(
+          "file_read",
+          { path: "deprecated/actor-token-signing-key" },
+          workspaceDir,
+        );
+        expect(risk).toBe(RiskLevel.High);
+      });
+
+      test("file_read of legacy protected signing key path is high risk", async () => {
+        const risk = await classifyRisk("file_read", {
+          path: join(
+            homedir(),
+            ".vellum",
+            "protected",
+            "actor-token-signing-key",
+          ),
+        });
+        expect(risk).toBe(RiskLevel.High);
+      });
     });
 
     // file_write is always low (sandboxed)

package/src/__tests__/clawhub.test.ts

@@ -1,4 +1,10 @@
-import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
 import { join } from "node:path";
 import { describe, expect, test } from "bun:test";
 import { mock } from "bun:test";
@@ -15,9 +21,9 @@ mock.module("../util/logger.js", () => ({
 import {
   clawhubInspect,
   clawhubInstall,
-  loadIntegrityManifest,
   verifyAndRecordSkillHash,
 } from "../skills/clawhub.js";
+import type { SkillInstallMeta } from "../skills/install-meta.js";
 
 // ---------------------------------------------------------------------------
 // Slug validation (exercised through public API)
@@ -92,58 +98,65 @@ describe("clawhubInspect slug validation", () => {
 });
 
 // ---------------------------------------------------------------------------
-// Integrity manifest edge cases — tested via verifyAndRecordSkillHash
-// which is the code path that reads/writes the manifest.
+// Content hash verification — tested via verifyAndRecordSkillHash
+// which reads legacy .integrity.json but always writes to install-meta.json.
 // ---------------------------------------------------------------------------
 
-describe("integrity manifest", () => {
+describe("content hash verification", () => {
   function createSkillFiles(slug: string): void {
     const skillDir = join(TEST_DIR, "skills", slug);
     mkdirSync(skillDir, { recursive: true });
     writeFileSync(join(skillDir, "SKILL.md"), "# Test Skill\n", "utf-8");
   }
 
+  function readSkillInstallMeta(slug: string): SkillInstallMeta {
+    const metaPath = join(TEST_DIR, "skills", slug, "install-meta.json");
+    return JSON.parse(readFileSync(metaPath, "utf-8")) as SkillInstallMeta;
+  }
+
   test("malformed integrity JSON is handled gracefully", () => {
     mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
     const integrityPath = join(TEST_DIR, "skills", ".integrity.json");
     writeFileSync(integrityPath, "{not valid json!!!", "utf-8");
     createSkillFiles("valid-slug");
 
-    // Should not throw — malformed manifest is replaced with a fresh one
+    // Should not throw — malformed legacy manifest is ignored; install-meta.json is created
     verifyAndRecordSkillHash("valid-slug");
 
-    // Manifest should now contain a valid entry
-    const manifest = loadIntegrityManifest();
-    expect(manifest["valid-slug"]).toBeDefined();
-    expect(manifest["valid-slug"].sha256).toMatch(/^v2:[0-9a-f]{64}$/);
+    // install-meta.json should now contain a valid hash
+    const meta = readSkillInstallMeta("valid-slug");
+    expect(meta.contentHash).toMatch(/^v2:[0-9a-f]{64}$/);
+    expect(meta.origin).toBe("clawhub");
+    expect(meta.slug).toBe("valid-slug");
   });
 
-  test("missing integrity manifest is created on first install", () => {
+  test("install-meta.json is created on first hash verification for skills without one", () => {
     const skillsDir = join(TEST_DIR, "skills");
     mkdirSync(skillsDir, { recursive: true });
-    const integrityPath = join(skillsDir, ".integrity.json");
-    // Remove any manifest left by earlier tests so we test the fresh-creation path
-    rmSync(integrityPath, { force: true });
-    expect(existsSync(integrityPath)).toBe(false);
     createSkillFiles("new-skill");
+    const metaPath = join(skillsDir, "new-skill", "install-meta.json");
+    // Remove any install-meta left by earlier tests
+    rmSync(metaPath, { force: true });
+    expect(existsSync(metaPath)).toBe(false);
 
     verifyAndRecordSkillHash("new-skill");
 
-    // Manifest should now exist with the skill's hash
-    expect(existsSync(integrityPath)).toBe(true);
-    const manifest = loadIntegrityManifest();
-    expect(manifest["new-skill"]).toBeDefined();
-    expect(manifest["new-skill"].sha256).toMatch(/^v2:[0-9a-f]{64}$/);
+    // install-meta.json should now exist with the skill's hash
+    expect(existsSync(metaPath)).toBe(true);
+    const meta = readSkillInstallMeta("new-skill");
+    expect(meta.contentHash).toMatch(/^v2:[0-9a-f]{64}$/);
+    expect(meta.origin).toBe("clawhub");
+    expect(meta.slug).toBe("new-skill");
   });
 
   test("re-install with same content preserves hash", () => {
     createSkillFiles("stable-skill");
 
     verifyAndRecordSkillHash("stable-skill");
-    const first = loadIntegrityManifest()["stable-skill"].sha256;
+    const first = readSkillInstallMeta("stable-skill").contentHash;
 
     verifyAndRecordSkillHash("stable-skill");
-    const second = loadIntegrityManifest()["stable-skill"].sha256;
+    const second = readSkillInstallMeta("stable-skill").contentHash;
 
     expect(first).toBe(second);
   });
@@ -151,7 +164,7 @@ describe("integrity manifest", () => {
   test("re-install with changed content updates hash", () => {
     createSkillFiles("changing-skill");
     verifyAndRecordSkillHash("changing-skill");
-    const first = loadIntegrityManifest()["changing-skill"].sha256;
+    const first = readSkillInstallMeta("changing-skill").contentHash;
 
     // Modify skill content
     writeFileSync(
@@ -160,8 +173,25 @@ describe("integrity manifest", () => {
       "utf-8",
     );
     verifyAndRecordSkillHash("changing-skill");
-    const second = loadIntegrityManifest()["changing-skill"].sha256;
+    const second = readSkillInstallMeta("changing-skill").contentHash;
 
     expect(first).not.toBe(second);
   });
+
+  test(".integrity.json is never written to", () => {
+    const skillsDir = join(TEST_DIR, "skills");
+    mkdirSync(skillsDir, { recursive: true });
+    const integrityPath = join(skillsDir, ".integrity.json");
+    // Remove any legacy manifest
+    rmSync(integrityPath, { force: true });
+    createSkillFiles("no-integrity-write");
+
+    verifyAndRecordSkillHash("no-integrity-write");
+
+    // .integrity.json should NOT have been created
+    expect(existsSync(integrityPath)).toBe(false);
+    // But install-meta.json should exist
+    const metaPath = join(skillsDir, "no-integrity-write", "install-meta.json");
+    expect(existsSync(metaPath)).toBe(true);
+  });
 });

package/src/__tests__/cli-command-risk-guard.test.ts

@@ -208,6 +208,20 @@ describe("CLI command risk guard: elevated assistant subcommands", () => {
     }
   });
 
+  test("--help used as option value does not downgrade credentials reveal risk", async () => {
+    const risk = await classifyRisk("bash", {
+      command: "assistant credentials reveal 123 --service --help",
+    });
+    expect(risk).toBe(RiskLevel.High);
+  });
+
+  test("-h used as option value does not downgrade oauth mode --set risk", async () => {
+    const risk = await classifyRisk("bash", {
+      command: "assistant oauth mode --set -h",
+    });
+    expect(risk).toBe(RiskLevel.High);
+  });
+
   test("non-sensitive oauth subcommands remain Low risk", async () => {
     const lowRiskOauthCommands = [
       "assistant oauth apps",

package/src/__tests__/cli-memory.test.ts

@@ -2,7 +2,7 @@ import { rmSync } from "node:fs";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { Command } from "commander";
-import { eq } from "drizzle-orm";
+import { eq, like } from "drizzle-orm";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -64,7 +64,7 @@ import {
   upsertCliCapabilityMemory,
 } from "../cli/cli-memory.js";
 import { getDb, initializeDb, resetDb } from "../memory/db.js";
-import { memoryItems, memoryJobs } from "../memory/schema.js";
+import { memoryGraphNodes, memoryJobs } from "../memory/schema.js";
 import { ensureDataDir, getDbPath } from "../util/platform.js";
 
 ensureDataDir();
@@ -76,9 +76,8 @@ afterAll(() => {
 
 function resetTables() {
   const db = getDb();
-  db.run("DELETE FROM memory_item_sources");
   db.run("DELETE FROM memory_embeddings");
-  db.run("DELETE FROM memory_items");
+  db.run("DELETE FROM memory_graph_nodes");
   db.run("DELETE FROM memory_jobs");
 }
 
@@ -103,62 +102,62 @@ describe("buildCliCapabilityStatement", () => {
 describe("upsertCliCapabilityMemory", () => {
   beforeEach(resetTables);
 
-  test("inserts with correct kind, subject, confidence, importance", () => {
+  test("inserts with correct type, content, confidence, significance", () => {
     upsertCliCapabilityMemory("doctor", "Run diagnostic checks");
 
     const db = getDb();
-    const items = db.select().from(memoryItems).all();
+    const items = db.select().from(memoryGraphNodes).all();
     expect(items).toHaveLength(1);
-    expect(items[0].kind).toBe("capability");
-    expect(items[0].subject).toBe("cli:doctor");
+    expect(items[0].type).toBe("procedural");
+    expect(items[0].content).toMatch(/^cli:doctor\n/);
     expect(items[0].confidence).toBe(1.0);
-    expect(items[0].importance).toBe(0.7);
-    expect(items[0].status).toBe("active");
+    expect(items[0].significance).toBe(0.7);
+    expect(items[0].fidelity).toBe("vivid");
     expect(items[0].scopeId).toBe("default");
 
-    // Should also enqueue an embed_item job
+    // Should also enqueue an embed_graph_node job
     const jobs = db.select().from(memoryJobs).all();
     expect(jobs).toHaveLength(1);
-    expect(jobs[0].type).toBe("embed_item");
+    expect(jobs[0].type).toBe("embed_graph_node");
   });
 
-  test("is idempotent (same entry only touches lastSeenAt)", () => {
+  test("is idempotent (same entry only touches lastAccessed)", () => {
     upsertCliCapabilityMemory("doctor", "Run diagnostic checks");
 
     const db = getDb();
-    const before = db.select().from(memoryItems).all();
+    const before = db.select().from(memoryGraphNodes).all();
     expect(before).toHaveLength(1);
-    const originalLastSeen = before[0].lastSeenAt;
+    const originalLastAccessed = before[0].lastAccessed;
 
     // Upsert again
     upsertCliCapabilityMemory("doctor", "Run diagnostic checks");
 
-    const after = db.select().from(memoryItems).all();
+    const after = db.select().from(memoryGraphNodes).all();
     expect(after).toHaveLength(1);
-    // Fingerprint should be the same, so only lastSeenAt changes
-    expect(after[0].fingerprint).toBe(before[0].fingerprint);
-    expect(after[0].lastSeenAt).toBeGreaterThanOrEqual(originalLastSeen);
+    // Same content, so only lastAccessed changes
+    expect(after[0].content).toBe(before[0].content);
+    expect(after[0].lastAccessed).toBeGreaterThanOrEqual(originalLastAccessed);
 
     // Should NOT enqueue a second embed job (only 1 from initial insert)
     const jobs = db.select().from(memoryJobs).all();
     expect(jobs).toHaveLength(1);
   });
 
-  test("updates statement when description changes", () => {
+  test("updates content when description changes", () => {
     upsertCliCapabilityMemory("doctor", "Original description");
 
     const db = getDb();
-    const before = db.select().from(memoryItems).all();
+    const before = db.select().from(memoryGraphNodes).all();
     expect(before).toHaveLength(1);
-    expect(before[0].statement).toContain("Original description");
+    expect(before[0].content).toContain("Original description");
 
     // Change description
     upsertCliCapabilityMemory("doctor", "Updated description");
 
-    const after = db.select().from(memoryItems).all();
+    const after = db.select().from(memoryGraphNodes).all();
     expect(after).toHaveLength(1);
-    expect(after[0].statement).toContain("Updated description");
-    expect(after[0].fingerprint).not.toBe(before[0].fingerprint);
+    expect(after[0].content).toContain("Updated description");
+    expect(after[0].content).not.toBe(before[0].content);
 
     // Should enqueue a second embed job
     const jobs = db.select().from(memoryJobs).all();
@@ -170,13 +169,13 @@ describe("upsertCliCapabilityMemory", () => {
 
     const db = getDb();
     // Soft-delete the item
-    db.update(memoryItems)
-      .set({ status: "deleted" })
-      .where(eq(memoryItems.subject, "cli:doctor"))
+    db.update(memoryGraphNodes)
+      .set({ fidelity: "gone" })
+      .where(like(memoryGraphNodes.content, "cli:doctor\n%"))
       .run();
 
-    const deleted = db.select().from(memoryItems).all();
-    expect(deleted[0].status).toBe("deleted");
+    const deleted = db.select().from(memoryGraphNodes).all();
+    expect(deleted[0].fidelity).toBe("gone");
 
     // Clear jobs from initial insert
     db.run("DELETE FROM memory_jobs");
@@ -184,20 +183,20 @@ describe("upsertCliCapabilityMemory", () => {
     // Upsert again — should reactivate
     upsertCliCapabilityMemory("doctor", "Run diagnostic checks");
 
-    const reactivated = db.select().from(memoryItems).all();
+    const reactivated = db.select().from(memoryGraphNodes).all();
     expect(reactivated).toHaveLength(1);
-    expect(reactivated[0].status).toBe("active");
+    expect(reactivated[0].fidelity).toBe("vivid");
 
     // Should enqueue embed job for reactivated item
     const jobs = db.select().from(memoryJobs).all();
     expect(jobs).toHaveLength(1);
-    expect(jobs[0].type).toBe("embed_item");
+    expect(jobs[0].type).toBe("embed_graph_node");
   });
 
   test("does not throw on DB error", () => {
     resetDb();
     const db = getDb();
-    db.run("DROP TABLE IF EXISTS memory_items");
+    db.run("DROP TABLE IF EXISTS memory_graph_nodes");
 
     expect(() => {
       upsertCliCapabilityMemory("doctor", "Run diagnostic checks");
@@ -234,21 +233,21 @@ describe("seedCliCommandMemories", () => {
     const db = getDb();
     const items = db
       .select()
-      .from(memoryItems)
-      .where(eq(memoryItems.kind, "capability"))
+      .from(memoryGraphNodes)
+      .where(eq(memoryGraphNodes.type, "procedural"))
       .all();
     expect(items).toHaveLength(3);
 
-    const subjects = items.map((i) => i.subject).sort();
-    expect(subjects).toEqual([
+    const contentPrefixes = items.map((i) => i.content.split("\n")[0]).sort();
+    expect(contentPrefixes).toEqual([
       "cli:config",
       "cli:doctor",
       "cli:keys",
     ]);
 
-    // All should be active
+    // All should be vivid
     for (const item of items) {
-      expect(item.status).toBe("active");
+      expect(item.fidelity).toBe("vivid");
     }
   });
 
@@ -264,11 +263,11 @@ describe("seedCliCommandMemories", () => {
     const db = getDb();
     const beforeItems = db
       .select()
-      .from(memoryItems)
-      .where(eq(memoryItems.kind, "capability"))
+      .from(memoryGraphNodes)
+      .where(eq(memoryGraphNodes.type, "procedural"))
       .all();
     expect(beforeItems).toHaveLength(3);
-    expect(beforeItems.every((i) => i.status === "active")).toBe(true);
+    expect(beforeItems.every((i) => i.fidelity === "vivid")).toBe(true);
 
     // Now seed with only doctor — config and keys should be pruned
     mockCommands = [
@@ -278,20 +277,20 @@ describe("seedCliCommandMemories", () => {
 
     const afterItems = db
       .select()
-      .from(memoryItems)
-      .where(eq(memoryItems.kind, "capability"))
+      .from(memoryGraphNodes)
+      .where(eq(memoryGraphNodes.type, "procedural"))
       .all();
     expect(afterItems).toHaveLength(3); // still 3 rows, but 2 are soft-deleted
 
-    const active = afterItems.filter((i) => i.status === "active");
-    const deleted = afterItems.filter((i) => i.status === "deleted");
+    const active = afterItems.filter((i) => i.fidelity === "vivid");
+    const deleted = afterItems.filter((i) => i.fidelity === "gone");
 
     expect(active).toHaveLength(1);
-    expect(active[0].subject).toBe("cli:doctor");
+    expect(active[0].content).toMatch(/^cli:doctor\n/);
 
     expect(deleted).toHaveLength(2);
-    const deletedSubjects = deleted.map((i) => i.subject).sort();
-    expect(deletedSubjects).toEqual(["cli:config", "cli:keys"]);
+    const deletedPrefixes = deleted.map((i) => i.content.split("\n")[0]).sort();
+    expect(deletedPrefixes).toEqual(["cli:config", "cli:keys"]);
   });
 
   test("handles empty command list without errors", () => {
@@ -299,38 +298,44 @@ describe("seedCliCommandMemories", () => {
     upsertCliCapabilityMemory("old-command", "An old command");
 
     const db = getDb();
-    const beforeItems = db.select().from(memoryItems).all();
+    const beforeItems = db.select().from(memoryGraphNodes).all();
     expect(beforeItems).toHaveLength(1);
-    expect(beforeItems[0].status).toBe("active");
+    expect(beforeItems[0].fidelity).toBe("vivid");
 
     // Seed with empty commands
     mockCommands = [];
     seedCliCommandMemories();
 
     // The existing command should be pruned (soft-deleted)
-    const afterItems = db.select().from(memoryItems).all();
+    const afterItems = db.select().from(memoryGraphNodes).all();
     expect(afterItems).toHaveLength(1);
-    expect(afterItems[0].status).toBe("deleted");
+    expect(afterItems[0].fidelity).toBe("gone");
   });
 
   test("does not prune non-cli capability memories", () => {
     // Pre-insert a skill capability memory directly into the DB
     const db = getDb();
     const now = Date.now();
-    db.insert(memoryItems)
+    db.insert(memoryGraphNodes)
       .values({
         id: "skill-test-item",
-        kind: "capability",
-        subject: "skill:test-skill",
-        statement: "The test skill does things.",
-        status: "active",
+        type: "procedural",
+        content: "skill:test-skill\nThe test skill does things.",
+        fidelity: "vivid",
         confidence: 1.0,
-        importance: 0.7,
-        fingerprint: "skill-test-fp",
-        sourceType: "extraction",
+        significance: 0.7,
+        sourceType: "inferred",
         scopeId: "default",
-        firstSeenAt: now,
-        lastSeenAt: now,
+        created: now,
+        lastAccessed: now,
+        lastConsolidated: now,
+        emotionalCharge: '{"valence":0,"intensity":0.1,"decayCurve":"linear","decayRate":0.05,"originalIntensity":0.1}',
+        stability: 14,
+        reinforcementCount: 0,
+        lastReinforced: now,
+        sourceConversations: "[]",
+        narrativeRole: null,
+        partOfStory: null,
       })
       .run();
 
@@ -340,11 +345,11 @@ describe("seedCliCommandMemories", () => {
 
     const item = db
       .select()
-      .from(memoryItems)
-      .where(eq(memoryItems.subject, "skill:test-skill"))
+      .from(memoryGraphNodes)
+      .where(like(memoryGraphNodes.content, "skill:test-skill\n%"))
       .get();
     expect(item).toBeDefined();
-    expect(item!.status).toBe("active");
+    expect(item!.fidelity).toBe("vivid");
   });
 
   test("does not throw on error", () => {
@@ -352,10 +357,10 @@ describe("seedCliCommandMemories", () => {
       { name: "doctor", description: "Run diagnostic checks" },
     ];
 
-    // Drop memory_items to force a DB error during the prune phase
+    // Drop memory_graph_nodes to force a DB error during the prune phase
     resetDb();
     const db = getDb();
-    db.run("DROP TABLE IF EXISTS memory_items");
+    db.run("DROP TABLE IF EXISTS memory_graph_nodes");
 
     expect(() => {
       seedCliCommandMemories();

package/src/__tests__/config-schema.test.ts

@@ -105,7 +105,7 @@ describe("AssistantConfigSchema", () => {
       shellMaxTimeoutSec: 600,
       permissionTimeoutSec: 300,
       toolExecutionTimeoutSec: 120,
-      providerStreamTimeoutSec: 300,
+      providerStreamTimeoutSec: 1800,
     });
     expect(result.sandbox).toEqual({
       enabled: false,