@vellumai/assistant 0.5.5 → 0.5.7

package/src/__tests__/shell-identity.test.ts

@@ -82,12 +82,76 @@ describe("deriveShellActionKeys", () => {
     ]);
   });
 
-  test("pipelines are marked non-simple", async () => {
+  test("pipelines are marked non-simple but produce action keys", async () => {
     const analysis = await analyzeShellCommand("git log | grep fix");
     const result = deriveShellActionKeys(analysis);
 
     expect(result.isSimpleAction).toBe(false);
-    expect(result.keys).toHaveLength(0);
+    expect(result.keys).toEqual([
+      { key: "action:git log", depth: 2 },
+      { key: "action:git", depth: 1 },
+    ]);
+  });
+
+  test("pipeline extracts action keys from first segment", async () => {
+    const analysis = await analyzeShellCommand(
+      "pdftotext file.pdf | head -100",
+    );
+    const result = deriveShellActionKeys(analysis);
+
+    expect(result.isSimpleAction).toBe(false);
+    // file.pdf is treated as a subcommand token (doesn't start with . or contain /)
+    expect(result.keys).toEqual([
+      { key: "action:pdftotext file.pdf", depth: 2 },
+      { key: "action:pdftotext", depth: 1 },
+    ]);
+  });
+
+  test("setup-prefix + pipeline extracts action keys", async () => {
+    const analysis = await analyzeShellCommand(
+      "cd /tmp && pdftotext file.pdf | grep oil",
+    );
+    const result = deriveShellActionKeys(analysis);
+
+    expect(result.isSimpleAction).toBe(false);
+    expect(result.keys).toEqual([
+      { key: "action:pdftotext file.pdf", depth: 2 },
+      { key: "action:pdftotext", depth: 1 },
+    ]);
+  });
+
+  test("pipeline with subcommand extracts deeper keys", async () => {
+    const analysis = await analyzeShellCommand("cd repo && gh pr list | head");
+    const result = deriveShellActionKeys(analysis);
+
+    expect(result.isSimpleAction).toBe(false);
+    expect(result.keys).toEqual([
+      { key: "action:gh pr list", depth: 3 },
+      { key: "action:gh pr", depth: 2 },
+      { key: "action:gh", depth: 1 },
+    ]);
+  });
+
+  test("multi-pipe pipeline extracts first segment only", async () => {
+    const analysis = await analyzeShellCommand("cat file | grep error | wc -l");
+    const result = deriveShellActionKeys(analysis);
+
+    expect(result.isSimpleAction).toBe(false);
+    expect(result.keys).toEqual([
+      { key: "action:cat file", depth: 2 },
+      { key: "action:cat", depth: 1 },
+    ]);
+  });
+
+  test("dangerous pipe_to_shell still extracts keys", async () => {
+    const analysis = await analyzeShellCommand("curl url | bash");
+    const result = deriveShellActionKeys(analysis);
+
+    expect(result.isSimpleAction).toBe(false);
+    expect(result.keys).toEqual([
+      { key: "action:curl url", depth: 2 },
+      { key: "action:curl", depth: 1 },
+    ]);
   });
 
   test("complex chains with multiple actions are non-simple", async () => {
@@ -198,9 +262,19 @@ describe("buildShellCommandCandidates", () => {
     expect(candidates).toEqual(['git add . && git commit -m "fix"']);
   });
 
-  test("pipeline returns raw-only", async () => {
+  test("pipeline returns raw and action key candidates", async () => {
     const candidates = await buildShellCommandCandidates("git log | grep fix");
-    expect(candidates).toEqual(["git log | grep fix"]);
+    expect(candidates[0]).toBe("git log | grep fix");
+    expect(candidates).toContain("action:git log");
+    expect(candidates).toContain("action:git");
+  });
+
+  test("pipeline with setup prefix includes action candidates", async () => {
+    const candidates = await buildShellCommandCandidates(
+      "cd /tmp && pdftotext file.pdf | wc -c",
+    );
+    expect(candidates[0]).toBe("cd /tmp && pdftotext file.pdf | wc -c");
+    expect(candidates).toContain("action:pdftotext");
   });
 
   test("candidate order is stable", async () => {
@@ -241,13 +315,29 @@ describe("buildShellAllowlistOptions — complex command restrictions", () => {
     expect(options[0].description).toContain("compound");
   });
 
-  test("pipeline offers exact only", async () => {
+  test("pipeline offers exact and action-key options", async () => {
     const options = await buildShellAllowlistOptions(
       "cat file.txt | grep error | wc -l",
     );
-    expect(options).toHaveLength(1);
+    expect(options.length).toBeGreaterThanOrEqual(2);
     expect(options[0].pattern).toBe("cat file.txt | grep error | wc -l");
     expect(options[0].description).toContain("compound");
+    expect(options.some((o) => o.pattern.startsWith("action:"))).toBe(true);
+  });
+
+  test("pipeline offers action-key options from first segment", async () => {
+    const options = await buildShellAllowlistOptions(
+      "pdftotext file.pdf | head -100",
+    );
+    expect(options.length).toBeGreaterThanOrEqual(2);
+    expect(options[0].pattern).toBe("pdftotext file.pdf | head -100");
+    expect(
+      options.some(
+        (o) =>
+          o.pattern === "action:pdftotext" &&
+          o.description.includes('Any "pdftotext" command'),
+      ),
+    ).toBe(true);
   });
 
   test("semicolon chain offers exact only", async () => {

package/src/__tests__/skill-feature-flags-integration.test.ts

@@ -5,9 +5,20 @@
  * parses it via the real frontmatter parser, and verifies that `skillFlagKey()`
  * returns the correct key and `resolveSkillStates()` correctly gates the skill.
  */
-import { describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import {
+  _setOverridesForTesting,
+  isAssistantFeatureFlagEnabled,
+} from "../config/assistant-feature-flags.js";
+
+beforeEach(() => {
+  _setOverridesForTesting({});
+});
+
+afterEach(() => {
+  _setOverridesForTesting({});
+});
 import type { AssistantConfig } from "../config/schema.js";
 import { resolveSkillStates, skillFlagKey } from "../config/skill-state.js";
 import type { SkillSummary } from "../config/skills.js";
@@ -150,12 +161,11 @@ describe("frontmatter feature-flag integration", () => {
   });
 
   test("resolveSkillStates includes skill with featureFlag when flag is ON", () => {
-    const skill = buildSkillSummary("contacts", SKILL_MD_WITH_FLAG)!;
-    const config = makeConfig({
-      assistantFeatureFlagValues: {
-        "feature_flags.contacts.enabled": true,
-      },
+    _setOverridesForTesting({
+      "feature_flags.contacts.enabled": true,
     });
+    const skill = buildSkillSummary("contacts", SKILL_MD_WITH_FLAG)!;
+    const config = makeConfig();
 
     const resolved = resolveSkillStates([skill], config);
     expect(resolved.length).toBe(1);
@@ -165,11 +175,10 @@ describe("frontmatter feature-flag integration", () => {
   test("resolveSkillStates never gates skill without featureFlag", () => {
     const skill = buildSkillSummary("plain-skill", SKILL_MD_WITHOUT_FLAG)!;
     // Even with an explicit false override for this skill ID, it should pass through
-    const config = makeConfig({
-      assistantFeatureFlagValues: {
-        "feature_flags.plain-skill.enabled": false,
-      },
+    _setOverridesForTesting({
+      "feature_flags.plain-skill.enabled": false,
     });
+    const config = makeConfig();
 
     const resolved = resolveSkillStates([skill], config);
     expect(resolved.length).toBe(1);
@@ -203,9 +212,8 @@ describe("frontmatter feature-flag integration", () => {
     expect(resolvedDefault[0].summary.id).toBe("contacts");
 
     // Step 6: With override disabled, skill is filtered out
-    const configOff = makeConfig({
-      assistantFeatureFlagValues: { [key!]: false },
-    });
+    _setOverridesForTesting({ [key!]: false });
+    const configOff = makeConfig();
     expect(isAssistantFeatureFlagEnabled(key!, configOff)).toBe(false);
 
     const resolvedOff = resolveSkillStates([skill], configOff);

package/src/__tests__/skill-feature-flags.test.ts

@@ -1,10 +1,21 @@
-import { describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import {
+  _setOverridesForTesting,
+  isAssistantFeatureFlagEnabled,
+} from "../config/assistant-feature-flags.js";
 import type { AssistantConfig } from "../config/schema.js";
 import { resolveSkillStates, skillFlagKey } from "../config/skill-state.js";
 import type { SkillSummary } from "../config/skills.js";
 
+beforeEach(() => {
+  _setOverridesForTesting({});
+});
+
+afterEach(() => {
+  _setOverridesForTesting({});
+});
+
 const DECLARED_FLAG_ID = "contacts";
 const DECLARED_FLAG_KEY = `feature_flags.${DECLARED_FLAG_ID}.enabled`;
 const DECLARED_SKILL_ID = "contacts";
@@ -92,9 +103,8 @@ describe("isAssistantFeatureFlagEnabled with skillFlagKey", () => {
   });
 
   test("returns true when skill key is explicitly true", () => {
-    const config = makeConfig({
-      assistantFeatureFlagValues: { [DECLARED_FLAG_KEY]: true },
-    });
+    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
+    const config = makeConfig();
     expect(
       isAssistantFeatureFlagEnabled(
         skillFlagKey({ featureFlag: DECLARED_FLAG_ID })!,
@@ -104,9 +114,8 @@ describe("isAssistantFeatureFlagEnabled with skillFlagKey", () => {
   });
 
   test("returns false when skill key is explicitly false", () => {
-    const config = makeConfig({
-      assistantFeatureFlagValues: { [DECLARED_FLAG_KEY]: false },
-    });
+    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
+    const config = makeConfig();
     expect(
       isAssistantFeatureFlagEnabled(
         skillFlagKey({ featureFlag: DECLARED_FLAG_ID })!,
@@ -128,11 +137,9 @@ describe("isAssistantFeatureFlagEnabled", () => {
     ).toBe(true);
   });
 
-  test("assistantFeatureFlagValues overrides registry default", () => {
-    const config = {
-      ...makeConfig(),
-      assistantFeatureFlagValues: { [DECLARED_FLAG_KEY]: false },
-    } as AssistantConfig;
+  test("file-based override overrides registry default", () => {
+    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
+    const config = makeConfig();
     expect(isAssistantFeatureFlagEnabled(DECLARED_FLAG_KEY, config)).toBe(
       false,
     );
@@ -145,9 +152,8 @@ describe("isAssistantFeatureFlagEnabled", () => {
   });
 
   test("respects persisted overrides for undeclared keys", () => {
-    const config = makeConfig({
-      assistantFeatureFlagValues: { "feature_flags.browser.enabled": false },
-    });
+    _setOverridesForTesting({ "feature_flags.browser.enabled": false });
+    const config = makeConfig();
     expect(
       isAssistantFeatureFlagEnabled("feature_flags.browser.enabled", config),
     ).toBe(false);
@@ -168,16 +174,15 @@ describe("isAssistantFeatureFlagEnabled", () => {
 
 describe("resolveSkillStates with feature flags", () => {
   test("flag OFF skill does not appear in resolved list", () => {
+    _setOverridesForTesting({
+      [DECLARED_FLAG_KEY]: false,
+      "feature_flags.browser.enabled": true,
+    });
     const catalog = [
       makeSkill(DECLARED_SKILL_ID, "bundled", DECLARED_FLAG_ID),
       makeSkill("browser", "bundled", "browser"),
     ];
-    const config = makeConfig({
-      assistantFeatureFlagValues: {
-        [DECLARED_FLAG_KEY]: false,
-        "feature_flags.browser.enabled": true,
-      },
-    });
+    const config = makeConfig();
 
     const resolved = resolveSkillStates(catalog, config);
     const ids = resolved.map((r) => r.summary.id);
@@ -187,16 +192,15 @@ describe("resolveSkillStates with feature flags", () => {
   });
 
   test("flag ON skill appears normally", () => {
+    _setOverridesForTesting({
+      [DECLARED_FLAG_KEY]: true,
+      "feature_flags.browser.enabled": true,
+    });
     const catalog = [
       makeSkill(DECLARED_SKILL_ID, "bundled", DECLARED_FLAG_ID),
       makeSkill("browser", "bundled", "browser"),
     ];
-    const config = makeConfig({
-      assistantFeatureFlagValues: {
-        [DECLARED_FLAG_KEY]: true,
-        "feature_flags.browser.enabled": true,
-      },
-    });
+    const config = makeConfig();
 
     const resolved = resolveSkillStates(catalog, config);
     const ids = resolved.map((r) => r.summary.id);
@@ -227,9 +231,9 @@ describe("resolveSkillStates with feature flags", () => {
   });
 
   test("feature flag OFF takes precedence over user-enabled config entry", () => {
+    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
     const catalog = [makeSkill(DECLARED_SKILL_ID, "bundled", DECLARED_FLAG_ID)];
     const config = makeConfig({
-      assistantFeatureFlagValues: { [DECLARED_FLAG_KEY]: false },
       skills: {
         entries: { [DECLARED_SKILL_ID]: { enabled: true } },
         load: { extraDirs: [], watch: true, watchDebounceMs: 250 },
@@ -253,18 +257,17 @@ describe("resolveSkillStates with feature flags", () => {
   });
 
   test("multiple skills with mixed flags — persisted overrides respected", () => {
+    _setOverridesForTesting({
+      [DECLARED_FLAG_KEY]: false,
+      "feature_flags.browser.enabled": true,
+      "feature_flags.deploy.enabled": false,
+    });
     const catalog = [
       makeSkill(DECLARED_SKILL_ID, "bundled", DECLARED_FLAG_ID),
       makeSkill("browser", "bundled", "browser"),
       makeSkill("deploy", "bundled", "deploy"),
     ];
-    const config = makeConfig({
-      assistantFeatureFlagValues: {
-        [DECLARED_FLAG_KEY]: false,
-        "feature_flags.browser.enabled": true,
-        "feature_flags.deploy.enabled": false,
-      },
-    });
+    const config = makeConfig();
 
     const resolved = resolveSkillStates(catalog, config);
     const ids = resolved.map((r) => r.summary.id);
@@ -290,11 +293,10 @@ describe("resolveSkillStates with frontmatter featureFlag", () => {
     expect(resolved[0].summary.id).toBe(DECLARED_SKILL_ID);
   });
 
-  test("skill with featureFlag is included when config override enables it", () => {
+  test("skill with featureFlag is included when override enables it", () => {
+    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
     const catalog = [makeSkill(DECLARED_SKILL_ID, "bundled", DECLARED_FLAG_ID)];
-    const config = makeConfig({
-      assistantFeatureFlagValues: { [DECLARED_FLAG_KEY]: true },
-    });
+    const config = makeConfig();
 
     const resolved = resolveSkillStates(catalog, config);
     const ids = resolved.map((r) => r.summary.id);
@@ -316,12 +318,11 @@ describe("resolveSkillStates with frontmatter featureFlag", () => {
     // This proves the implicit skillId→flag mapping is gone:
     // setting feature_flags.my-skill.enabled = false has no effect
     // when the skill itself does not declare a featureFlag.
-    const catalog = [makeSkill("my-skill")];
-    const config = makeConfig({
-      assistantFeatureFlagValues: {
-        "feature_flags.my-skill.enabled": false,
-      },
+    _setOverridesForTesting({
+      "feature_flags.my-skill.enabled": false,
     });
+    const catalog = [makeSkill("my-skill")];
+    const config = makeConfig();
 
     const resolved = resolveSkillStates(catalog, config);
     const ids = resolved.map((r) => r.summary.id);

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

@@ -7,6 +7,8 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
+
 const TEST_DIR = join(
   tmpdir(),
   `vellum-skill-load-flag-test-${crypto.randomUUID()}`,
@@ -75,7 +77,6 @@ mock.module("../config/loader.js", () => ({
   invalidateConfigCache: () => {},
   getNestedValue: () => undefined,
   setNestedValue: () => {},
-  syncConfigToLockfile: () => {},
 }));
 
 await import("../tools/skills/load.js");
@@ -113,9 +114,11 @@ describe("skill_load feature flag enforcement", () => {
   beforeEach(() => {
     mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
     currentConfig = {};
+    _setOverridesForTesting({});
   });
 
   afterEach(() => {
+    _setOverridesForTesting({});
     if (existsSync(TEST_DIR)) {
       rmSync(TEST_DIR, { recursive: true, force: true });
     }
@@ -133,9 +136,7 @@ describe("skill_load feature flag enforcement", () => {
       `- ${DECLARED_SKILL_ID}\n`,
     );
 
-    currentConfig = {
-      assistantFeatureFlagValues: { [DECLARED_FLAG_KEY]: false },
-    };
+    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
 
     const result = await executeSkillLoad({ skill: DECLARED_SKILL_ID });
 
@@ -156,9 +157,7 @@ describe("skill_load feature flag enforcement", () => {
       `- ${DECLARED_SKILL_ID}\n`,
     );
 
-    currentConfig = {
-      assistantFeatureFlagValues: { [DECLARED_FLAG_KEY]: true },
-    };
+    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
 
     const result = await executeSkillLoad({ skill: DECLARED_SKILL_ID });
 
@@ -178,9 +177,7 @@ describe("skill_load feature flag enforcement", () => {
       `- ${DECLARED_SKILL_ID}\n`,
     );
 
-    currentConfig = {
-      assistantFeatureFlagValues: {},
-    };
+    // No overrides — uses registry defaults
 
     const result = await executeSkillLoad({ skill: DECLARED_SKILL_ID });
 

package/src/__tests__/skill-load-inline-command.test.ts

@@ -21,6 +21,8 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
+
 // ── Test directory ────────────────────────────────────────────────────────────
 
 const TEST_DIR = mkdtempSync(
@@ -50,9 +52,7 @@ const platformOverrides: Record<string, (...args: unknown[]) => unknown> = {
   getSessionTokenPath: () => join(TEST_DIR, "session-token"),
   readSessionToken: () => null,
   getClipboardCommand: () => null,
-  readLockfile: () => null,
   normalizeAssistantId: (id: unknown) => String(id),
-  writeLockfile: () => {},
   getEmbeddingModelsDir: () => join(TEST_DIR, "embedding-models"),
   getTCPPort: () => 8765,
   isTCPEnabled: () => false,
@@ -127,7 +127,6 @@ interface TestConfig {
   permissions: { mode: "strict" | "workspace" };
   skills: { load: { extraDirs: string[] } };
   sandbox: { enabled: boolean };
-  assistantFeatureFlagValues?: Record<string, boolean>;
   [key: string]: unknown;
 }
 
@@ -135,9 +134,6 @@ const testConfig: TestConfig = {
   permissions: { mode: "workspace" },
   skills: { load: { extraDirs: [] } },
   sandbox: { enabled: true },
-  assistantFeatureFlagValues: {
-    "feature_flags.inline-skill-commands.enabled": true,
-  },
 };
 
 mock.module("../config/loader.js", () => ({
@@ -215,9 +211,9 @@ describe("skill_load inline command expansion", () => {
     }));
 
     // Enable the feature flag
-    testConfig.assistantFeatureFlagValues = {
+    _setOverridesForTesting({
       "feature_flags.inline-skill-commands.enabled": true,
-    };
+    });
     testConfig.skills = { load: { extraDirs: [] } };
   });
 
@@ -316,9 +312,9 @@ describe("skill_load inline command expansion", () => {
 
   describe("feature flag disabled", () => {
     test("returns error when flag is off and skill has inline commands", async () => {
-      testConfig.assistantFeatureFlagValues = {
+      _setOverridesForTesting({
         "feature_flags.inline-skill-commands.enabled": false,
-      };
+      });
 
       writeSkill(
         "flagged-off-skill",
@@ -337,9 +333,9 @@ describe("skill_load inline command expansion", () => {
     });
 
     test("plain skill still loads when flag is off", async () => {
-      testConfig.assistantFeatureFlagValues = {
+      _setOverridesForTesting({
         "feature_flags.inline-skill-commands.enabled": false,
-      };
+      });
 
       writeSkill(
         "plain-flag-off",

package/src/__tests__/skill-load-inline-includes.test.ts

@@ -23,6 +23,8 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
+
 // ── Test directory ────────────────────────────────────────────────────────────
 
 const TEST_DIR = mkdtempSync(
@@ -52,9 +54,7 @@ const platformOverrides: Record<string, (...args: unknown[]) => unknown> = {
   getSessionTokenPath: () => join(TEST_DIR, "session-token"),
   readSessionToken: () => null,
   getClipboardCommand: () => null,
-  readLockfile: () => null,
   normalizeAssistantId: (id: unknown) => String(id),
-  writeLockfile: () => {},
   getEmbeddingModelsDir: () => join(TEST_DIR, "embedding-models"),
   getTCPPort: () => 8765,
   isTCPEnabled: () => false,
@@ -129,7 +129,6 @@ interface TestConfig {
   permissions: { mode: "strict" | "workspace" };
   skills: { load: { extraDirs: string[] } };
   sandbox: { enabled: boolean };
-  assistantFeatureFlagValues?: Record<string, boolean>;
   [key: string]: unknown;
 }
 
@@ -137,9 +136,6 @@ const testConfig: TestConfig = {
   permissions: { mode: "workspace" },
   skills: { load: { extraDirs: [] } },
   sandbox: { enabled: true },
-  assistantFeatureFlagValues: {
-    "feature_flags.inline-skill-commands.enabled": true,
-  },
 };
 
 mock.module("../config/loader.js", () => ({
@@ -225,9 +221,9 @@ describe("skill_load inline command expansion for included skills", () => {
     }));
 
     // Enable the feature flag
-    testConfig.assistantFeatureFlagValues = {
+    _setOverridesForTesting({
       "feature_flags.inline-skill-commands.enabled": true,
-    };
+    });
     testConfig.skills = { load: { extraDirs: [] } };
   });
 
@@ -575,9 +571,9 @@ describe("skill_load inline command expansion for included skills", () => {
 
   describe("feature flag disabled for included skills", () => {
     test("skill_load returns error when child has inline commands and flag is off", async () => {
-      testConfig.assistantFeatureFlagValues = {
+      _setOverridesForTesting({
         "feature_flags.inline-skill-commands.enabled": false,
-      };
+      });
 
       writeSkill(
         "child-flag-off",

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

@@ -38,9 +38,7 @@ const platformOverrides: Record<string, (...args: unknown[]) => unknown> = {
   getSessionTokenPath: () => join(TEST_DIR, "session-token"),
   readSessionToken: () => null,
   getClipboardCommand: () => null,
-  readLockfile: () => null,
   normalizeAssistantId: (id: unknown) => String(id),
-  writeLockfile: () => {},
   getEmbeddingModelsDir: () => join(TEST_DIR, "embedding-models"),
   getTCPPort: () => 8765,
   isTCPEnabled: () => false,