@vellumai/assistant 0.4.48 → 0.4.50

package/src/__tests__/session-workspace-tool-tracking.test.ts

@@ -43,8 +43,9 @@ mock.module("../config/loader.js", () => ({
     contextWindow: {
       enabled: true,
       maxInputTokens: 100000,
-      targetBudgetRatio: 0.30,
-      compactThreshold: 0.8,      summaryBudgetRatio: 0.05,
+      targetBudgetRatio: 0.3,
+      compactThreshold: 0.8,
+      summaryBudgetRatio: 0.05,
       overflowRecovery: {
         enabled: true,
         safetyMarginRatio: 0.05,
@@ -138,23 +139,14 @@ mock.module("../memory/retriever.js", () => ({
     provider: "mock",
     model: "mock",
     injectedText: "",
-    lexicalHits: 0,
     semanticHits: 0,
     recencyHits: 0,
-    entityHits: 0,
-    relationSeedEntityCount: 0,
-    relationTraversedEdgeCount: 0,
-    relationNeighborEntityCount: 0,
-    relationExpandedItemCount: 0,
-    earlyTerminated: false,
     mergedCount: 0,
     selectedCount: 0,
-    rerankApplied: false,
     injectedTokens: 0,
     latencyMs: 0,
     topCandidates: [],
   }),
-  injectMemoryRecallIntoUserMessage: (msg: Message) => msg,
   injectMemoryRecallAsSeparateMessage: (msgs: Message[]) => msgs,
   stripMemoryRecallMessages: (msgs: Message[]) => msgs,
 }));
@@ -179,32 +171,6 @@ mock.module("../context/window-manager.js", () => ({
   }),
   getSummaryFromContextMessage: () => null,
 }));
-mock.module("../memory/conflict-store.js", () => ({
-  listPendingConflictDetails: () => [],
-  applyConflictResolution: () => true,
-}));
-mock.module("../memory/clarification-resolver.js", () => ({
-  resolveConflictClarification: async () => ({
-    resolution: "still_unclear",
-    strategy: "heuristic",
-    resolvedStatement: null,
-    explanation: "",
-  }),
-}));
-mock.module("../memory/admin.js", () => ({
-  getMemoryConflictAndCleanupStats: () => ({
-    conflicts: { pending: 0, resolved: 0, oldestPendingAgeMs: null },
-    cleanup: {
-      resolvedBacklog: 0,
-      supersededBacklog: 0,
-      resolvedCompleted24h: 0,
-      supersededCompleted24h: 0,
-    },
-  }),
-}));
-mock.module("../memory/profile-compiler.js", () => ({
-  compileDynamicProfile: () => null,
-}));
 mock.module("../memory/llm-usage-store.js", () => ({
   recordUsageEvent: () => ({ id: "usage-1", createdAt: Date.now() }),
 }));

package/src/__tests__/skill-include-graph.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import type { SkillSummary } from "../config/skills.js";
 import {
+  collectAllMissing,
   getImmediateChildren,
   indexCatalogById,
   traverseIncludes,
@@ -298,3 +299,68 @@ describe("validateIncludes — cycle detection", () => {
     }
   });
 });
+
+describe("collectAllMissing", () => {
+  test("returns empty set when skill has no includes", () => {
+    const catalog = [makeSkill("root")];
+    const index = indexCatalogById(catalog);
+    expect(collectAllMissing("root", index)).toEqual(new Set([]));
+  });
+
+  test("returns empty set when all includes are present", () => {
+    const catalog = [makeSkill("A", ["B"]), makeSkill("B")];
+    const index = indexCatalogById(catalog);
+    expect(collectAllMissing("A", index)).toEqual(new Set([]));
+  });
+
+  test("returns immediate missing children", () => {
+    const catalog = [makeSkill("A", ["B", "C"]), makeSkill("C")];
+    const index = indexCatalogById(catalog);
+    expect(collectAllMissing("A", index)).toEqual(new Set(["B"]));
+  });
+
+  test("returns transitive missing children", () => {
+    const catalog = [makeSkill("A", ["B"]), makeSkill("B", ["C"])];
+    const index = indexCatalogById(catalog);
+    expect(collectAllMissing("A", index)).toEqual(new Set(["C"]));
+  });
+
+  test("returns multiple missing at different levels", () => {
+    // A→B→C, B present but C missing
+    const catalog1 = [makeSkill("A", ["B"]), makeSkill("B", ["C"])];
+    const index1 = indexCatalogById(catalog1);
+    expect(collectAllMissing("A", index1)).toEqual(new Set(["C"]));
+
+    // A includes B and C, both missing
+    const catalog2 = [makeSkill("A", ["B", "C"])];
+    const index2 = indexCatalogById(catalog2);
+    expect(collectAllMissing("A", index2)).toEqual(new Set(["B", "C"]));
+  });
+
+  test("handles diamond with missing leaf", () => {
+    const catalog = [
+      makeSkill("A", ["B", "C"]),
+      makeSkill("B", ["D"]),
+      makeSkill("C", ["D"]),
+    ];
+    const index = indexCatalogById(catalog);
+    const result = collectAllMissing("A", index);
+    expect(result).toEqual(new Set(["D"]));
+    // Verify no duplicates (Set handles this, but confirm size)
+    expect(result.size).toBe(1);
+  });
+
+  test("does not loop infinitely on cycles", () => {
+    const catalog = [makeSkill("A", ["B"]), makeSkill("B", ["A"])];
+    const index = indexCatalogById(catalog);
+    expect(collectAllMissing("A", index)).toEqual(new Set([]));
+  });
+
+  test("handles cycle with missing node", () => {
+    const catalog = [makeSkill("A", ["B"]), makeSkill("B", ["C"])];
+    // C is missing, and if C referenced B it would be a cycle — but C isn't in catalog
+    // So A→B→C, C missing
+    const index = indexCatalogById(catalog);
+    expect(collectAllMissing("A", index)).toEqual(new Set(["C"]));
+  });
+});

package/src/__tests__/skill-load-feature-flag.test.ts

@@ -61,7 +61,6 @@ mock.module("../util/logger.js", () => ({
   ...realLogger,
   getLogger: () => noopLogger,
   getCliLogger: () => noopLogger,
-  isDebug: () => false,
   truncateForLog: (value: string) => value,
   initLogger: () => {},
   pruneOldLogFiles: () => 0,

package/src/__tests__/skill-load-tool.test.ts

@@ -60,10 +60,16 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
     }),
-  isDebug: () => false,
   truncateForLog: (s: unknown) => String(s),
 }));
 
+// Mock autoInstallFromCatalog — default returns false (not found in catalog).
+// Tests can override via `mockAutoInstall.mockImplementation(...)`.
+const mockAutoInstall = mock((_skillId: string) => Promise.resolve(false));
+mock.module("../skills/catalog-install.js", () => ({
+  autoInstallFromCatalog: (skillId: string) => mockAutoInstall(skillId),
+}));
+
 await import("../tools/skills/load.js");
 const { getTool } = await import("../tools/registry.js");
 
@@ -145,6 +151,10 @@ async function executeSkillLoad(
 describe("skill_load tool", () => {
   beforeEach(() => {
     mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
+    mockAutoInstall.mockReset();
+    mockAutoInstall.mockImplementation((_skillId: string) =>
+      Promise.resolve(false),
+    );
   });
 
   afterEach(() => {
@@ -850,4 +860,142 @@ describe("skill_load tool", () => {
       "Use `skill_execute` to call these tools.",
     );
   });
+
+  test("auto-installs missing includes from catalog", async () => {
+    // Parent includes "dep-a" which is not initially in the catalog
+    writeSkillWithIncludes(
+      "auto-parent",
+      "Auto Parent",
+      "Has auto-installable dep",
+      "Parent body",
+      ["dep-a"],
+    );
+    writeFileSync(join(TEST_DIR, "skills", "SKILLS.md"), "- auto-parent\n");
+
+    // Mock autoInstallFromCatalog to succeed and write the skill to disk
+    mockAutoInstall.mockImplementation((skillId: string) => {
+      if (skillId === "dep-a") {
+        writeSkill("dep-a", "Dep A", "A dependency", "Dep A body");
+        // Add to SKILLS.md so catalog reload finds it
+        writeFileSync(
+          join(TEST_DIR, "skills", "SKILLS.md"),
+          "- auto-parent\n- dep-a\n",
+        );
+        return Promise.resolve(true);
+      }
+      return Promise.resolve(false);
+    });
+
+    const result = await executeSkillLoad({ skill: "auto-parent" });
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Skill: Auto Parent");
+    expect(result.content).toContain("<loaded_skill");
+    expect(mockAutoInstall).toHaveBeenCalledWith("dep-a");
+  });
+
+  test("auto-installs transitive missing includes across rounds", async () => {
+    // Skill A includes B, B includes C. Neither B nor C in initial catalog.
+    writeSkillWithIncludes("trans-a", "Trans A", "Top level", "Body A", [
+      "trans-b",
+    ]);
+    writeFileSync(join(TEST_DIR, "skills", "SKILLS.md"), "- trans-a\n");
+
+    let round = 0;
+    mockAutoInstall.mockImplementation((skillId: string) => {
+      if (skillId === "trans-b" && round === 0) {
+        // First round: install B (which includes C)
+        writeSkillWithIncludes("trans-b", "Trans B", "Mid level", "Body B", [
+          "trans-c",
+        ]);
+        writeFileSync(
+          join(TEST_DIR, "skills", "SKILLS.md"),
+          "- trans-a\n- trans-b\n",
+        );
+        round++;
+        return Promise.resolve(true);
+      }
+      if (skillId === "trans-c") {
+        // Second round: install C
+        writeSkill("trans-c", "Trans C", "Leaf", "Body C");
+        writeFileSync(
+          join(TEST_DIR, "skills", "SKILLS.md"),
+          "- trans-a\n- trans-b\n- trans-c\n",
+        );
+        return Promise.resolve(true);
+      }
+      return Promise.resolve(false);
+    });
+
+    const result = await executeSkillLoad({ skill: "trans-a" });
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Skill: Trans A");
+    expect(result.content).toContain("<loaded_skill");
+    expect(mockAutoInstall).toHaveBeenCalledWith("trans-b");
+    expect(mockAutoInstall).toHaveBeenCalledWith("trans-c");
+  });
+
+  test("returns error when auto-install of missing include fails", async () => {
+    writeSkillWithIncludes(
+      "fail-parent",
+      "Fail Parent",
+      "Has failing dep",
+      "Body",
+      ["dep-x"],
+    );
+    writeFileSync(join(TEST_DIR, "skills", "SKILLS.md"), "- fail-parent\n");
+
+    // autoInstallFromCatalog throws an error
+    mockAutoInstall.mockImplementation((skillId: string) => {
+      if (skillId === "dep-x") {
+        return Promise.reject(new Error("Network error"));
+      }
+      return Promise.resolve(false);
+    });
+
+    const result = await executeSkillLoad({ skill: "fail-parent" });
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("dep-x");
+    expect(result.content).toContain("not found");
+    expect(result.content).not.toContain("<loaded_skill");
+  });
+
+  test("stops after MAX_INSTALL_ROUNDS", async () => {
+    // Pathological case: each install round reveals a new missing dep
+    writeSkillWithIncludes("loop-root", "Loop Root", "Infinite deps", "Body", [
+      "loop-dep-0",
+    ]);
+    writeFileSync(join(TEST_DIR, "skills", "SKILLS.md"), "- loop-root\n");
+
+    let installCount = 0;
+    mockAutoInstall.mockImplementation((skillId: string) => {
+      const id = skillId;
+      if (id.startsWith("loop-dep-")) {
+        installCount++;
+        const nextDepId = `loop-dep-${installCount}`;
+        // Install the requested dep, but it includes yet another missing dep
+        writeSkillWithIncludes(
+          id,
+          `Loop Dep ${installCount}`,
+          "Generated dep",
+          "Body",
+          [nextDepId],
+        );
+        // Update SKILLS.md to include all installed deps so far
+        const entries = ["- loop-root\n"];
+        for (let i = 0; i < installCount; i++) {
+          entries.push(`- loop-dep-${i}\n`);
+        }
+        writeFileSync(join(TEST_DIR, "skills", "SKILLS.md"), entries.join(""));
+        return Promise.resolve(true);
+      }
+      return Promise.resolve(false);
+    });
+
+    const result = await executeSkillLoad({ skill: "loop-root" });
+    // Should terminate with an error (the final dep is still missing)
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("not found");
+    // Should have terminated — installCount should be bounded by MAX_INSTALL_ROUNDS (5)
+    expect(installCount).toBeLessThanOrEqual(5);
+  });
 });

package/src/__tests__/skill-projection-feature-flag.test.ts

@@ -210,7 +210,6 @@ mock.module("../util/logger.js", () => ({
     debug: () => {},
     error: () => {},
   }),
-  isDebug: () => false,
 }));
 
 // ---------------------------------------------------------------------------

package/src/__tests__/skills-install-extract.test.ts

@@ -0,0 +1,93 @@
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { extractTarToDir } from "../skills/catalog-install.js";
+
+let tempDir: string;
+
+function makeTarEntry(name: string, content: string): Buffer {
+  const header = Buffer.alloc(512, 0);
+  const nameBuffer = Buffer.from(name, "utf-8");
+  nameBuffer.copy(header, 0, 0, Math.min(nameBuffer.length, 100));
+
+  const mode = Buffer.from("0000644\0", "ascii");
+  mode.copy(header, 100);
+  Buffer.from("0000000\0", "ascii").copy(header, 108); // uid
+  Buffer.from("0000000\0", "ascii").copy(header, 116); // gid
+
+  const sizeOct = content.length.toString(8).padStart(11, "0") + "\0";
+  Buffer.from(sizeOct, "ascii").copy(header, 124);
+
+  Buffer.from("00000000000\0", "ascii").copy(header, 136); // mtime
+  Buffer.from("        ", "ascii").copy(header, 148); // checksum placeholder
+  header[156] = "0".charCodeAt(0);
+  Buffer.from("ustar\0", "ascii").copy(header, 257);
+  Buffer.from("00", "ascii").copy(header, 263);
+
+  let sum = 0;
+  for (let i = 0; i < 512; i += 1) sum += header[i] ?? 0;
+  const checksum = sum.toString(8).padStart(6, "0");
+  Buffer.from(`${checksum}\0 `, "ascii").copy(header, 148);
+
+  const data = Buffer.from(content, "utf-8");
+  const paddedSize = Math.ceil(data.length / 512) * 512;
+  const padded = Buffer.alloc(paddedSize, 0);
+  data.copy(padded);
+
+  return Buffer.concat([header, padded]);
+}
+
+function makeTar(entries: Array<{ name: string; content: string }>): Buffer {
+  const body = entries.map((entry) => makeTarEntry(entry.name, entry.content));
+  return Buffer.concat([...body, Buffer.alloc(1024, 0)]);
+}
+
+beforeEach(() => {
+  tempDir = join(
+    tmpdir(),
+    `skills-extract-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(tempDir, { recursive: true });
+});
+
+afterEach(() => {
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+describe("extractTarToDir", () => {
+  test("extracts valid files and detects SKILL.md", () => {
+    const tar = makeTar([
+      { name: "SKILL.md", content: "# demo\n" },
+      { name: "scripts/run.sh", content: "echo ok\n" },
+    ]);
+
+    const foundSkillMd = extractTarToDir(tar, tempDir);
+
+    expect(foundSkillMd).toBe(true);
+    expect(readFileSync(join(tempDir, "SKILL.md"), "utf-8")).toBe("# demo\n");
+    expect(readFileSync(join(tempDir, "scripts", "run.sh"), "utf-8")).toBe(
+      "echo ok\n",
+    );
+  });
+
+  test("rejects traversal and absolute archive paths", () => {
+    const tar = makeTar([
+      { name: "SKILL.md", content: "# demo\n" },
+      { name: "../../escape.txt", content: "nope\n" },
+      { name: "..\\..\\win-escape.txt", content: "nope\n" },
+      { name: "/absolute.txt", content: "nope\n" },
+      { name: "C:/windows.txt", content: "nope\n" },
+    ]);
+
+    const foundSkillMd = extractTarToDir(tar, tempDir);
+
+    expect(foundSkillMd).toBe(true);
+    expect(existsSync(join(tempDir, "escape.txt"))).toBe(false);
+    expect(existsSync(join(tempDir, "win-escape.txt"))).toBe(false);
+    expect(existsSync(join(tempDir, "absolute.txt"))).toBe(false);
+    expect(existsSync(join(tempDir, "windows.txt"))).toBe(false);
+    expect(readFileSync(join(tempDir, "SKILL.md"), "utf-8")).toBe("# demo\n");
+  });
+});

package/src/__tests__/skills-uninstall.test.ts

@@ -9,7 +9,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import { uninstallSkillLocally } from "../cli/commands/skills.js";
+import { uninstallSkillLocally } from "../skills/catalog-install.js";
 
 let tempDir: string;
 let originalBaseDataDir: string | undefined;

package/src/__tests__/skills.test.ts

@@ -60,7 +60,6 @@ mock.module("../util/logger.js", () => ({
   ...realLogger,
   getLogger: () => noopLogger,
   getCliLogger: () => noopLogger,
-  isDebug: () => false,
   truncateForLog: (v: string) => v,
   initLogger: () => {},
   pruneOldLogFiles: () => 0,
@@ -719,15 +718,16 @@ describe("bundled computer-use skill", () => {
     expect(cuSkill!.disableModelInvocation).toBe(true);
   });
 
-  test("computer-use skill has a valid tool manifest with 12 tools", () => {
+  test("computer-use skill has a valid tool manifest with 11 tools", () => {
     const catalog = loadSkillCatalog();
     const cuSkill = catalog.find((s) => s.id === "computer-use");
     expect(cuSkill).toBeDefined();
     expect(cuSkill!.toolManifest).toBeDefined();
     expect(cuSkill!.toolManifest!.present).toBe(true);
     expect(cuSkill!.toolManifest!.valid).toBe(true);
-    expect(cuSkill!.toolManifest!.toolCount).toBe(10);
+    expect(cuSkill!.toolManifest!.toolCount).toBe(11);
     expect(cuSkill!.toolManifest!.toolNames).toEqual([
+      "computer_use_observe",
       "computer_use_click",
       "computer_use_type_text",
       "computer_use_key",