@vellumai/assistant 0.4.46 → 0.4.49

package/src/__tests__/script-proxy-injection-runtime.test.ts

@@ -1,6 +1,7 @@
 import * as http from "node:http";
 import { afterEach, describe, expect, mock, test } from "bun:test";
 
+import { credentialKey } from "../security/credential-key.js";
 import type { CredentialMetadata } from "../tools/credentials/metadata-store.js";
 import type { CredentialInjectionTemplate } from "../tools/credentials/policy-types.js";
 import type { ResolvedCredential } from "../tools/credentials/resolve.js";
@@ -82,7 +83,7 @@ function makeResolved(
     credentialId,
     service,
     field,
-    storageKey: `credential:${service}:${field}`,
+    storageKey: credentialKey(service, field),
     injectionTemplates: templates,
     metadata: {
       credentialId,
@@ -154,7 +155,7 @@ describe("policyCallback credential injection", () => {
       resolveByIdResults.set("cred-local", resolved);
       credentialMetadataList.push(resolved.metadata);
       secureKeyValues.set(
-        "credential:test-service:api-key",
+        credentialKey("test-service", "api-key"),
         "fal_secretvalue123",
       );
 
@@ -194,7 +195,10 @@ describe("policyCallback credential injection", () => {
       const resolved = makeResolved("cred-bearer", [tpl]);
       resolveByIdResults.set("cred-bearer", resolved);
       credentialMetadataList.push(resolved.metadata);
-      secureKeyValues.set("credential:test-service:api-key", "tok_abc123");
+      secureKeyValues.set(
+        credentialKey("test-service", "api-key"),
+        "tok_abc123",
+      );
 
       const session = createSession(
         CONV_ID,
@@ -311,7 +315,7 @@ describe("MITM rewriteCallback credential injection", () => {
     const tpl = makeTemplate("*.fal.ai", "authorization", "Key ");
     const resolved = makeResolved("cred-fal", [tpl]);
     resolveByIdResults.set("cred-fal", resolved);
-    secureKeyValues.set("credential:test-service:api-key", "fal_secret");
+    secureKeyValues.set(credentialKey("test-service", "api-key"), "fal_secret");
 
     const templates = new Map([["cred-fal", [tpl]]]);
     const headers: Record<string, string> = {
@@ -350,7 +354,7 @@ describe("MITM rewriteCallback credential injection", () => {
 
     const tpl = makeTemplate("*.fal.ai", "authorization", "Key ");
     resolveByIdResults.set("cred-fal", makeResolved("cred-fal", [tpl]));
-    secureKeyValues.set("credential:test-service:api-key", "fal_secret");
+    secureKeyValues.set(credentialKey("test-service", "api-key"), "fal_secret");
 
     const templates = new Map([["cred-fal", [tpl]]]);
     const headers: Record<string, string> = {
@@ -479,8 +483,8 @@ describe("composeWith injection", () => {
       );
       resolveByServiceFieldResults.set("twilio:auth_token", composedResolved);
 
-      secureKeyValues.set("credential:twilio:account_sid", "ACtest123");
-      secureKeyValues.set("credential:twilio:auth_token", "secret456");
+      secureKeyValues.set(credentialKey("twilio", "account_sid"), "ACtest123");
+      secureKeyValues.set(credentialKey("twilio", "auth_token"), "secret456");
 
       const session = createSession(
         CONV_ID,
@@ -531,7 +535,7 @@ describe("composeWith injection", () => {
       );
       resolveByIdResults.set("cred-primary", primaryResolved);
       credentialMetadataList.push(primaryResolved.metadata);
-      secureKeyValues.set("credential:twilio:account_sid", "ACtest123");
+      secureKeyValues.set(credentialKey("twilio", "account_sid"), "ACtest123");
 
       // Do NOT register the composed credential in resolveByServiceFieldResults
 
@@ -578,7 +582,10 @@ describe("composeWith injection", () => {
       const resolved = makeResolved("cred-b64", [tpl]);
       resolveByIdResults.set("cred-b64", resolved);
       credentialMetadataList.push(resolved.metadata);
-      secureKeyValues.set("credential:test-service:api-key", "plaintext");
+      secureKeyValues.set(
+        credentialKey("test-service", "api-key"),
+        "plaintext",
+      );
 
       const session = createSession(CONV_ID, ["cred-b64"], undefined, DATA_DIR);
       const started = await startSession(session.id);
@@ -624,7 +631,7 @@ describe("composeWith injection", () => {
       );
       resolveByIdResults.set("cred-primary", primaryResolved);
       credentialMetadataList.push(primaryResolved.metadata);
-      secureKeyValues.set("credential:twilio:account_sid", "ACtest123");
+      secureKeyValues.set(credentialKey("twilio", "account_sid"), "ACtest123");
 
       // Composed credential metadata resolves, but no secret value stored
       const composedResolved = makeResolved(
@@ -634,7 +641,7 @@ describe("composeWith injection", () => {
         "auth_token",
       );
       resolveByServiceFieldResults.set("twilio:auth_token", composedResolved);
-      // Do NOT set secureKeyValues for "credential:twilio:auth_token"
+      // Do NOT set secureKeyValues for credentialKey("twilio", "auth_token")
 
       const session = createSession(
         CONV_ID,
@@ -700,8 +707,11 @@ describe("composeWith injection", () => {
         composedResolved,
       );
 
-      secureKeyValues.set("credential:my-service:primary-key", "value1");
-      secureKeyValues.set("credential:my-service:secondary-key", "value2");
+      secureKeyValues.set(credentialKey("my-service", "primary-key"), "value1");
+      secureKeyValues.set(
+        credentialKey("my-service", "secondary-key"),
+        "value2",
+      );
 
       const session = createSession(
         CONV_ID,

package/src/__tests__/script-proxy-policy-runtime.test.ts

@@ -64,7 +64,7 @@ function makeResolved(
     credentialId,
     service: "test-service",
     field: "api-key",
-    storageKey: `credential:test-service:api-key`,
+    storageKey: `credential/test-service/api-key`,
     injectionTemplates: templates,
     metadata: {
       credentialId,

package/src/__tests__/script-proxy-session-manager.test.ts

@@ -56,7 +56,7 @@ function makeResolved(
     credentialId,
     service: "test-service",
     field: "api-key",
-    storageKey: `credential:test-service:api-key`,
+    storageKey: `credential/test-service/api-key`,
     injectionTemplates: templates,
     metadata: {
       credentialId,

package/src/__tests__/secret-ingress-handler.test.ts

@@ -22,7 +22,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
     }),
-  isDebug: () => false,
 }));
 
 const { checkIngressForSecrets } =

package/src/__tests__/secret-onetime-send.test.ts

@@ -69,6 +69,8 @@ mock.module("./policy-validate.js", () => ({
   }),
 }));
 
+import { credentialKey } from "../security/credential-key.js";
+
 const { credentialStoreTool } = await import("../tools/credentials/vault.js");
 
 describe("one-time send override", () => {
@@ -96,7 +98,7 @@ describe("one-time send override", () => {
     expect(result.isError).toBe(true);
     expect(result.content).toContain("not enabled");
     // Value must NOT be stored in keychain
-    expect(storedKeys.has("credential:svc:key")).toBe(false);
+    expect(storedKeys.has(credentialKey("svc", "key"))).toBe(false);
   });
 
   test("transient_send succeeds when allowOneTimeSend is enabled", async () => {
@@ -119,7 +121,7 @@ describe("one-time send override", () => {
     expect(result.isError).toBe(false);
     expect(result.content).toContain("NOT saved");
     // Value must NOT be stored in keychain
-    expect(storedKeys.has("credential:svc:key")).toBe(false);
+    expect(storedKeys.has(credentialKey("svc", "key"))).toBe(false);
   });
 
   test("store delivery always persists to keychain regardless of allowOneTimeSend", async () => {
@@ -138,7 +140,7 @@ describe("one-time send override", () => {
     );
     expect(result.isError).toBe(false);
     expect(result.content).toContain("stored");
-    expect(storedKeys.has("credential:svc:key")).toBe(true);
+    expect(storedKeys.has(credentialKey("svc", "key"))).toBe(true);
   });
 
   test("transient_send response content never contains the secret value", async () => {

package/src/__tests__/send-endpoint-busy.test.ts

@@ -117,6 +117,7 @@ function makeCompletingSession(): Session {
     updateClient: () => {},
     setHostBashProxy: () => {},
     setHostFileProxy: () => {},
+    setHostCuProxy: () => {},
     hasAnyPendingConfirmation: () => false,
     hasPendingConfirmation: () => false,
     denyAllPendingConfirmations: () => {},
@@ -173,6 +174,7 @@ function makeHangingSession(): Session {
     updateClient: () => {},
     setHostBashProxy: () => {},
     setHostFileProxy: () => {},
+    setHostCuProxy: () => {},
     hasAnyPendingConfirmation: () => false,
     hasPendingConfirmation: () => false,
     denyAllPendingConfirmations: () => {},
@@ -257,6 +259,7 @@ function makePendingApprovalSession(
     updateClient: () => {},
     setHostBashProxy: () => {},
     setHostFileProxy: () => {},
+    setHostCuProxy: () => {},
     hasAnyPendingConfirmation: () => pending.size > 0,
     hasPendingConfirmation: (candidateRequestId: string) =>
       pending.has(candidateRequestId),
@@ -364,11 +367,17 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
         interface: "macos",
       }),
     });
-    const body = (await res.json()) as { accepted: boolean; messageId: string };
+    const body = (await res.json()) as {
+      accepted: boolean;
+      messageId: string;
+      conversationId: string;
+    };
 
     expect(res.status).toBe(202);
     expect(body.accepted).toBe(true);
     expect(body.messageId).toBeDefined();
+    expect(typeof body.conversationId).toBe("string");
+    expect(body.conversationId.length).toBeGreaterThan(0);
 
     await stopServer();
   });
@@ -485,8 +494,8 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
     createCanonicalGuardianRequest({
       id: requestId,
       kind: "tool_approval",
-      sourceType: "desktop",
-      sourceChannel: "vellum",
+      sourceType: "voice",
+      sourceChannel: "slack",
       conversationId,
       toolName: "call_start",
       status: "pending",
@@ -511,8 +520,8 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
       body: JSON.stringify({
         conversationKey,
         content: "sure let's do that",
-        sourceChannel: "vellum",
-        interface: "macos",
+        sourceChannel: "slack",
+        interface: "slack",
       }),
     });
     const body = (await res.json()) as {
@@ -808,11 +817,17 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
         interface: "macos",
       }),
     });
-    const body2 = (await res2.json()) as { accepted: boolean; queued: boolean };
+    const body2 = (await res2.json()) as {
+      accepted: boolean;
+      queued: boolean;
+      conversationId: string;
+    };
 
     expect(res2.status).toBe(202);
     expect(body2.accepted).toBe(true);
     expect(body2.queued).toBe(true);
+    expect(typeof body2.conversationId).toBe("string");
+    expect(body2.conversationId.length).toBeGreaterThan(0);
 
     await stopServer();
   });

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

@@ -22,7 +22,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
     }),
-  isDebug: () => false,
   truncateForLog: (value: string) => value,
 }));
 

package/src/__tests__/session-init.benchmark.test.ts

@@ -127,7 +127,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
     }),
-  isDebug: () => false,
   truncateForLog: (value: string, maxLen = 500) =>
     value.length > maxLen ? value.slice(0, maxLen) + "..." : value,
   initLogger: () => {},
@@ -342,7 +341,7 @@ describe("Session initialization benchmark", () => {
     }
 
     timings.sort((a, b) => a - b);
-    expect(median(timings)).toBeLessThan(10);
+    expect(median(timings)).toBeLessThan(15);
   });
 
   test("buildSystemPrompt assembles prompt under 50ms (median of 5)", () => {
@@ -384,9 +383,9 @@ describe("Session initialization benchmark", () => {
     await initializeTools();
     const definitions = getAllToolDefinitions();
 
-    // Sanity: we expect a meaningful number of core tools (at least 20)
+    // Sanity: we expect a meaningful number of core tools (at least 18)
     // but not an unreasonable explosion (under 200)
-    expect(definitions.length).toBeGreaterThanOrEqual(20);
+    expect(definitions.length).toBeGreaterThanOrEqual(18);
     expect(definitions.length).toBeLessThan(200);
   });
 });
@@ -548,6 +547,6 @@ describe("End-to-end session creation benchmark", () => {
     }
 
     timings.sort((a, b) => a - b);
-    expect(median(timings)).toBeLessThan(10);
+    expect(median(timings)).toBeLessThan(15);
   });
 });

package/src/__tests__/session-messaging-secret-redirect.test.ts

@@ -5,6 +5,7 @@ import {
   redirectToSecurePrompt,
 } from "../daemon/session-messaging.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
+import { credentialKey } from "../security/credential-key.js";
 
 const setSecureKeyMock = mock((_key?: string, _value?: string) => true);
 const upsertCredentialMetadataMock = mock(
@@ -108,7 +109,7 @@ describe("session-messaging secret redirect", () => {
       label: "Telegram Bot Token",
     });
     expect(setSecureKeyMock).toHaveBeenCalledWith(
-      "credential:telegram:bot_token",
+      credentialKey("telegram", "bot_token"),
       "123456789:ABCDefGHIJklmnopQRSTuvwxyz012345678",
     );
     expect(upsertCredentialMetadataMock).toHaveBeenCalledWith(
@@ -158,7 +159,7 @@ describe("session-messaging secret redirect", () => {
       label: "Telegram Bot Token",
     });
     expect(setSecureKeyMock).toHaveBeenCalledWith(
-      "credential:telegram:bot_token",
+      credentialKey("telegram", "bot_token"),
       "123456789:ABCDefGHIJklmnopQRSTuvwxyz012345678",
     );
   });
@@ -197,7 +198,7 @@ describe("session-messaging secret redirect", () => {
       label: "Telegram Bot Token",
     });
     expect(setSecureKeyMock).toHaveBeenCalledWith(
-      "credential:telegram:bot_token",
+      credentialKey("telegram", "bot_token"),
       "123456789:ABCDefGHIJklmnopQRSTuvwxyz012345678",
     );
   });
@@ -231,7 +232,7 @@ describe("session-messaging secret redirect", () => {
       label: "Secure Credential Entry",
     });
     expect(setSecureKeyMock).toHaveBeenCalledWith(
-      "credential:detected:Some Unknown Secret",
+      credentialKey("detected", "Some Unknown Secret"),
       "opaque-secret",
     );
     expect(upsertCredentialMetadataMock).toHaveBeenCalledWith(

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-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;
@@ -58,7 +58,7 @@ describe("assistant skills uninstall", () => {
 
     // GIVEN a skill is installed locally
     installFakeSkill("weather");
-    writeSkillsIndex("- weather\n- google-oauth-setup\n");
+    writeSkillsIndex("- weather\n- google-oauth-applescript\n");
 
     // WHEN we uninstall the skill
     uninstallSkillLocally("weather");
@@ -71,7 +71,7 @@ describe("assistant skills uninstall", () => {
     expect(index).not.toContain("weather");
 
     // AND other skills should remain in the index
-    expect(index).toContain("google-oauth-setup");
+    expect(index).toContain("google-oauth-applescript");
   });
 
   test("errors when skill is not installed", () => {