@vellumai/assistant 0.8.1 → 0.8.3

package/src/__tests__/external-plugin-loader.test.ts

@@ -70,8 +70,6 @@ describe("loadExternalPlugin — manifest", () => {
     );
     expect(registered).toBeDefined();
     expect(registered?.manifest.version).toBe("1.2.3");
-    // Defaults to pluginRuntime v1 when no `vellum.requires` is set.
-    expect(registered?.manifest.requires).toEqual({ pluginRuntime: "v1" });
   });
 
   test("strips npm scope from name", async () => {
@@ -97,56 +95,84 @@ describe("loadExternalPlugin — manifest", () => {
     );
     expect(registered?.manifest.version).toBe("0.0.0");
   });
+});
 
-  test("reads vellum.requires from package.json when present", async () => {
-    // Future direction (out of scope this PR): `requires` may carry
-    // `assistantVersion` alongside `pluginRuntime`. For today the registry
-    // validates against `ASSISTANT_API_VERSIONS` and only `pluginRuntime`
-    // is a known capability — so the loader's pass-through behavior is
-    // exercised with the keys the registry already accepts. The loader is
-    // opaque to the shape; additional keys propagate identically.
-    const dir = freshPluginDir("custom-requires");
+describe("loadExternalPlugin — plugin-api peerDependency", () => {
+  // Tests anchor against assistantPkg.version (read from the assistant's
+  // own package.json) so the matrix below stays correct across version
+  // bumps. Constructing a range from the live version + nudging up/down
+  // by one keeps the satisfy/un-satisfy cases honest.
+  test("loads when peerDependency range satisfies assistant version", async () => {
+    const dir = freshPluginDir("compat-ok");
     writePackageJson(dir, {
-      name: "custom-requires",
+      name: "compat-ok",
       version: "0.1.0",
-      vellum: { requires: { pluginRuntime: "v1" } },
+      peerDependencies: { "@vellumai/plugin-api": "*" },
     });
 
     await loadExternalPlugin(dir);
 
-    const registered = getRegisteredPlugins().find(
-      (p) => p.manifest.name === "custom-requires",
-    );
-    expect(registered?.manifest.requires).toEqual({ pluginRuntime: "v1" });
+    expect(registeredNames()).toContain("compat-ok");
   });
 
-  test("vellum.requires overrides the default — empty requires fails registration", async () => {
-    // Belt-and-suspenders proof that the loader reads `vellum.requires`
-    // rather than always defaulting: an empty `vellum.requires` propagates
-    // through, the registry rejects the plugin (missing pluginRuntime),
-    // and the registry stays empty.
-    const dir = freshPluginDir("empty-requires");
+  test("loads plugin whose peerDependency range excludes assistant version (logs error)", async () => {
+    // The host-compat gate is soft while the installation flow is in
+    // flux — an unsatisfied range produces a `log.error` but the
+    // plugin still loads. Once installation settles, this case should
+    // harden back into a hard reject.
+    const dir = freshPluginDir("compat-bad");
     writePackageJson(dir, {
-      name: "empty-requires",
+      name: "compat-bad",
       version: "0.1.0",
-      vellum: { requires: {} },
+      // A range that no real assistant version will satisfy.
+      peerDependencies: { "@vellumai/plugin-api": ">=999.0.0" },
     });
 
     await loadExternalPlugin(dir);
 
-    expect(registeredNames()).not.toContain("empty-requires");
+    expect(registeredNames()).toContain("compat-bad");
   });
 
-  test("does not synthesize a provides field", async () => {
-    const dir = freshPluginDir("no-provides");
-    writePackageJson(dir, { name: "no-provides", version: "0.1.0" });
+  test("loads plugin whose peerDependency range is unparseable (logs error)", async () => {
+    // Same soft-gate rationale as the excluded-range case above.
+    const dir = freshPluginDir("compat-bogus");
+    writePackageJson(dir, {
+      name: "compat-bogus",
+      version: "0.1.0",
+      peerDependencies: { "@vellumai/plugin-api": "not-a-real-range" },
+    });
 
     await loadExternalPlugin(dir);
 
-    const registered = getRegisteredPlugins().find(
-      (p) => p.manifest.name === "no-provides",
-    );
-    expect(registered?.manifest.provides).toBeUndefined();
+    expect(registeredNames()).toContain("compat-bogus");
+  });
+
+  test("loads with warning when no peerDependency on plugin-api is declared", async () => {
+    // Absent peerDep is non-fatal — the loader logs a warn and proceeds
+    // with no host-compat claim. The convention is opt-in while the
+    // plugin-api framework is experimental.
+    const dir = freshPluginDir("compat-absent");
+    writePackageJson(dir, {
+      name: "compat-absent",
+      version: "0.1.0",
+    });
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toContain("compat-absent");
+  });
+
+  test("loads with warning when peerDependencies is present but lacks plugin-api key", async () => {
+    const dir = freshPluginDir("compat-other-peer");
+    writePackageJson(dir, {
+      name: "compat-other-peer",
+      version: "0.1.0",
+      peerDependencies: { react: "^18.0.0" },
+    });
+
+    await loadExternalPlugin(dir);
+
+    expect(registeredNames()).toContain("compat-other-peer");
   });
 
   test("malformed package.json is logged and skipped (registry untouched)", async () => {
@@ -197,9 +223,9 @@ describe("loadExternalPlugin — hooks", () => {
     );
     expect(typeof registered?.hooks?.init).toBe("function");
     await registered?.hooks?.init?.({} as never);
-    expect(
-      (globalThis as Record<string, unknown>).__externalInitCalled,
-    ).toBe(true);
+    expect((globalThis as Record<string, unknown>).__externalInitCalled).toBe(
+      true,
+    );
     delete (globalThis as Record<string, unknown>).__externalInitCalled;
   });
 
@@ -264,9 +290,9 @@ describe("loadExternalPlugin — hooks", () => {
     expect(Object.keys(registered?.hooks ?? {})).toEqual(["init"]);
     expect(typeof registered?.hooks?.init).toBe("function");
     await registered?.hooks?.init?.({} as never);
-    expect((globalThis as Record<string, unknown>).__externalDtsInitCalled).toBe(
-      true,
-    );
+    expect(
+      (globalThis as Record<string, unknown>).__externalDtsInitCalled,
+    ).toBe(true);
     delete (globalThis as Record<string, unknown>).__externalDtsInitCalled;
   });
 
@@ -319,11 +345,9 @@ describe("loadExternalPlugin — tools", () => {
       dir,
       "tools/alpha.ts",
       `export default {
-  name: "two_tools_alpha",
   description: "alpha",
-  category: "plugin",
   defaultRiskLevel: "low" as const,
-  getDefinition() { return { name: "two_tools_alpha", description: "alpha", input_schema: { type: "object", properties: {}, required: [] } }; },
+  input_schema: { type: "object", properties: {}, required: [] },
   async execute() { return { content: "a", isError: false }; },
 };
 `,
@@ -332,11 +356,9 @@ describe("loadExternalPlugin — tools", () => {
       dir,
       "tools/beta.ts",
       `export default {
-  name: "two_tools_beta",
   description: "beta",
-  category: "plugin",
   defaultRiskLevel: "low" as const,
-  getDefinition() { return { name: "two_tools_beta", description: "beta", input_schema: { type: "object", properties: {}, required: [] } }; },
+  input_schema: { type: "object", properties: {}, required: [] },
   async execute() { return { content: "b", isError: false }; },
 };
 `,
@@ -350,7 +372,7 @@ describe("loadExternalPlugin — tools", () => {
     const names = (registered?.tools ?? []).map(
       (t) => (t as { name: string }).name,
     );
-    expect(names).toEqual(["two_tools_alpha", "two_tools_beta"]);
+    expect(names).toEqual(["alpha", "beta"]);
   });
 
   test("plugin.tools is undefined when tools/ is absent", async () => {
@@ -379,18 +401,95 @@ describe("loadExternalPlugin — tools", () => {
     expect(registeredNames()).toHaveLength(0);
   });
 
-  test("a tool default export missing string name is logged and skipped", async () => {
-    const dir = freshPluginDir("tool-no-name");
-    writePackageJson(dir, { name: "tool-no-name", version: "0.1.0" });
+  test("a tool default export with missing fields loads with documented defaults", async () => {
+    const dir = freshPluginDir("tool-with-defaults");
+    writePackageJson(dir, { name: "tool-with-defaults", version: "0.1.0" });
+    // The default export is a bare empty object — no description,
+    // defaultRiskLevel, input_schema, or execute. The loader must fill
+    // each slot with its documented default and still register the plugin.
+    writeSurfaceFile(dir, "tools/empty.ts", `export default {};\n`);
+
+    await loadExternalPlugin(dir);
+
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "tool-with-defaults",
+    );
+    expect(registered).toBeDefined();
+    const tools = (registered?.tools ?? []) as Array<{
+      name: string;
+      description: string;
+      defaultRiskLevel: string;
+      input_schema: Record<string, unknown>;
+      execute: (
+        input: Record<string, unknown>,
+        context: unknown,
+      ) => Promise<{ content: string; isError: boolean }>;
+    }>;
+    expect(tools).toHaveLength(1);
+    const empty = tools[0]!;
+    expect(empty.name).toBe("empty");
+    expect(empty.description).toBe("");
+    expect(empty.defaultRiskLevel).toBe("medium");
+    expect(empty.input_schema).toEqual({
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+    });
+    expect(typeof empty.execute).toBe("function");
+
+    const result = await empty.execute({}, {} as unknown);
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("empty");
+    expect(result.content).toContain("no execute implementation");
+  });
+
+  test("a partial tool default export merges author fields with defaults", async () => {
+    const dir = freshPluginDir("tool-partial-defaults");
+    writePackageJson(dir, {
+      name: "tool-partial-defaults",
+      version: "0.1.0",
+    });
+    // Author supplies only description + execute; the loader must default
+    // defaultRiskLevel and input_schema while keeping the author's fields.
     writeSurfaceFile(
       dir,
-      "tools/nameless.ts",
-      `export default { description: "missing name" };\n`,
+      "tools/partial.ts",
+      `export default {
+  description: "custom description",
+  async execute() {
+    return { content: "ran", isError: false };
+  },
+};
+`,
     );
 
     await loadExternalPlugin(dir);
 
-    expect(registeredNames()).toHaveLength(0);
+    const registered = getRegisteredPlugins().find(
+      (p) => p.manifest.name === "tool-partial-defaults",
+    );
+    const tool = (registered?.tools ?? [])[0] as
+      | {
+          description: string;
+          defaultRiskLevel: string;
+          input_schema: object;
+          execute: (
+            input: Record<string, unknown>,
+            context: unknown,
+          ) => Promise<{ content: string; isError: boolean }>;
+        }
+      | undefined;
+    expect(tool).toBeDefined();
+    expect(tool?.description).toBe("custom description");
+    expect(tool?.defaultRiskLevel).toBe("medium");
+    expect(tool?.input_schema).toEqual({
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+    });
+    const result = await tool!.execute({}, {} as unknown);
+    expect(result.isError).toBe(false);
+    expect(result.content).toBe("ran");
   });
 });
 
@@ -450,9 +549,6 @@ describe("loadExternalPlugin — end-to-end @vellumai/simple-memory", () => {
     const toolNames = (registered?.tools ?? [])
       .map((t) => (t as { name: string }).name)
       .sort();
-    expect(toolNames).toEqual([
-      "simple_memory_recall",
-      "simple_memory_remember",
-    ]);
+    expect(toolNames).toEqual(["recall", "remember"]);
   });
 });

package/src/__tests__/filing-service.test.ts

@@ -303,6 +303,146 @@ describe("FilingService", () => {
       expect(processMessageCalls).toHaveLength(1);
     });
 
+    // Helpers for the compaction-retry tests: hold the filing run open by
+    // making processMessage return a manually-resolved promise, so `activeRun`
+    // stays set and runCompactionOnce() sees the contention path.
+    function holdFilingRun(): {
+      release: () => void;
+      filingCalls: () => number;
+      compactionCalls: () => number;
+      waitForFilingStarted: () => Promise<void>;
+    } {
+      let release: (() => void) | undefined;
+      let started = false;
+      let filingCalls = 0;
+      let compactionCalls = 0;
+
+      setTestProcessMessage((...args: unknown[]) => {
+        const callSite = (args[3] as { callSite?: string } | undefined)
+          ?.callSite;
+        if (callSite === "filingAgent") {
+          filingCalls += 1;
+          started = true;
+          return new Promise((resolve) => {
+            release = () => resolve({ messageId: "filing-done" });
+          });
+        }
+        if (callSite === "compactionAgent") {
+          compactionCalls += 1;
+        }
+        return Promise.resolve({ messageId: "mock" });
+      });
+
+      return {
+        release: () => release?.(),
+        filingCalls: () => filingCalls,
+        compactionCalls: () => compactionCalls,
+        waitForFilingStarted: async () => {
+          while (!started) await Promise.resolve();
+        },
+      };
+    }
+
+    test("schedules a near-term retry when filing run is in-flight", async () => {
+      const hold = holdFilingRun();
+      // 5s retry override paired with a production-realistic 24h compaction
+      // interval — the assertion proves retry << interval.
+      const retryMs = 5_000;
+      mockConfig.filing.compactionIntervalMs = 24 * 60 * 60 * 1000;
+      const service = new FilingService({
+        compactionContendedRetryMs: retryMs,
+      });
+      const filingPromise = service.runOnce();
+      await hold.waitForFilingStarted();
+
+      const beforeRetry = Date.now();
+      const ran = await service.runCompactionOnce();
+
+      expect(ran).toBe(false);
+      expect(service.nextCompactionAt).not.toBeNull();
+      const nextAt = service.nextCompactionAt!;
+      expect(nextAt - beforeRetry).toBeLessThan(
+        mockConfig.filing.compactionIntervalMs,
+      );
+      expect(nextAt - beforeRetry).toBeLessThanOrEqual(retryMs + 100);
+
+      hold.release();
+      await filingPromise;
+      await service.stop();
+    });
+
+    test("retry fires after filing run completes", async () => {
+      const hold = holdFilingRun();
+      const service = new FilingService({ compactionContendedRetryMs: 1 });
+      const filingPromise = service.runOnce();
+      await hold.waitForFilingStarted();
+
+      const skipped = await service.runCompactionOnce();
+      expect(skipped).toBe(false);
+      expect(hold.compactionCalls()).toBe(0);
+
+      hold.release();
+      await filingPromise;
+
+      const start = Date.now();
+      while (hold.compactionCalls() === 0 && Date.now() - start < 1000) {
+        await new Promise((resolve) => setTimeout(resolve, 5));
+      }
+
+      expect(hold.filingCalls()).toBe(1);
+      expect(hold.compactionCalls()).toBe(1);
+
+      await service.stop();
+    });
+
+    test("stop() clears a scheduled compaction retry", async () => {
+      const hold = holdFilingRun();
+      const service = new FilingService({ compactionContendedRetryMs: 50 });
+      const filingPromise = service.runOnce();
+      await hold.waitForFilingStarted();
+      await service.runCompactionOnce();
+      expect(service.nextCompactionAt).not.toBeNull();
+
+      hold.release();
+      await filingPromise;
+      await service.stop();
+
+      // After stop, the retry timer must be cleared and never fire.
+      expect(service.nextCompactionAt).toBeNull();
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      expect(hold.compactionCalls()).toBe(0);
+    });
+
+    test("stop() prevents retry callback from re-arming a fresh timer", async () => {
+      // Race: the retry callback fires while filing is still in-flight and
+      // stop() has begun. The callback already cleared compactionRetryTimer,
+      // so clearCompactionRetry is a no-op. Without a stopped flag, the
+      // callback's runCompactionOnce() hits the activeRun branch and schedules
+      // a fresh retry, leaving a live timer after stop() resolves.
+      const hold = holdFilingRun();
+      const service = new FilingService({ compactionContendedRetryMs: 5 });
+      const filingPromise = service.runOnce();
+      await hold.waitForFilingStarted();
+      await service.runCompactionOnce();
+      expect(service.nextCompactionAt).not.toBeNull();
+
+      // Begin stop without awaiting — it would block on the held filing run.
+      // stop() flips `stopped` synchronously before the retry timer fires.
+      const stopPromise = service.stop();
+
+      // Wait past the retry delay. Without the guard, the callback would call
+      // runCompactionOnce(), observe activeRun, and re-arm a new retry.
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      expect(service.nextCompactionAt).toBeNull();
+
+      hold.release();
+      await filingPromise;
+      await stopPromise;
+
+      expect(service.nextCompactionAt).toBeNull();
+      expect(hold.compactionCalls()).toBe(0);
+    });
+
     test("respects active hours", async () => {
       mockConfig.filing.activeHoursStart = 9;
       mockConfig.filing.activeHoursEnd = 17;

package/src/__tests__/get-skill-detail-audit.test.ts

@@ -150,13 +150,11 @@ mock.module("../skills/clawhub-files.js", () => ({
 
 mock.module("../skills/catalog-install.js", () => ({
   installSkillLocally: async () => {},
-  upsertSkillsIndex: () => {},
 }));
 
 mock.module("../skills/managed-store.js", () => ({
   createManagedSkill: () => ({ created: true }),
   deleteManagedSkill: () => ({ deleted: true }),
-  removeSkillsIndexEntry: () => {},
   validateManagedSkillId: () => null,
 }));
 
@@ -188,8 +186,6 @@ import { getSkill } from "../daemon/handlers/skills.js";
 // Helpers
 // ---------------------------------------------------------------------------
 
-
-
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------

package/src/__tests__/guardian-action-no-hardcoded-copy.test.ts

@@ -20,7 +20,6 @@ const SCANNED_FILES = [
   "calls/call-controller.ts",
   "calls/guardian-action-sweep.ts",
   "runtime/routes/inbound-message-handler.ts",
-  "runtime/guardian-action-conversation-turn.ts",
   "daemon/conversation-process.ts",
 ];
 

package/src/__tests__/guardian-dispatch.test.ts

@@ -295,6 +295,7 @@ describe("guardian-dispatch", () => {
       conversationId: "conv-from-thread-created",
       title: "Guardian alert",
       sourceEventName: "guardian.question",
+      silent: false,
     };
     mockEmitResult = {
       signalId: "sig-4",

package/src/__tests__/handlers-skills-memory-v2-reseed.test.ts

@@ -3,18 +3,13 @@
  * `assistant/src/daemon/handlers/skills.ts`.
  *
  * One representative call site (the `installSkill` bundled branch) is
- * exercised — all 5 sites share the same delegation to
- * `maybeSeedMemoryV2Skills`, so a single suite covers behavior. Validates:
- *   - config on → helper invoked after seedSkillGraphNodes and the seed
- *     observed (callOrder picks up "v2")
- *   - config off → helper still invoked, but the seed short-circuits
+ * exercised; all handler seed sites share the same delegation to
+ * `refreshSkillCapabilityMemories`, so a single suite covers behavior. Validates:
+ *   - handler invokes the centralized refresh helper with the live config.
  *
- * The handler delegates to `maybeSeedMemoryV2Skills` from
- * `daemon/memory-v2-startup.ts`. We mock that module directly so the test
- * does not have to drain the dynamic-import microtask chain. The helper's
- * gate semantics are covered by `lifecycle-memory-v2-seed.test.ts`; here
- * we only verify that the handler invokes the helper synchronously with
- * the live config.
+ * The helper's gate semantics (flag + config + rejection swallowing) are
+ * covered by `lifecycle-memory-v2-seed.test.ts`; here we only verify that the
+ * handler delegates to the centralized refresh path synchronously.
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -22,16 +17,9 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 // Programmable test state
 // ---------------------------------------------------------------------------
 
-const flagsState = { configV2Enabled: true };
+const configState = { v2Enabled: true };
 
-const callOrder: string[] = [];
-
-const mockSeedSkillGraphNodes = mock(() => {
-  callOrder.push("v1");
-});
-// Body installed in `beforeEach` so each test sees a fresh implementation
-// that closes over the up-to-date `flagsState`.
-const mockMaybeSeedMemoryV2Skills = mock(
+const mockRefreshSkillCapabilityMemories = mock(
   (_config: { memory: { v2: { enabled: boolean } } }) => {},
 );
 
@@ -53,10 +41,6 @@ mock.module("../config/skills.js", () => ({
   ],
 }));
 
-mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: () => true,
-}));
-
 // Stub both `getConfig` and `loadConfig`. `loadConfig` is reached by code
 // paths transitively imported during teardown (e.g. dynamic imports inside
 // `oauth2.ts`); leaving it undefined here would break sibling test files
@@ -68,13 +52,13 @@ mock.module("../config/loader.js", () => ({
   deepMergeOverwrite: (a: unknown) => a,
   mergeDefaultWorkspaceConfig: () => {},
   getConfig: () => ({
-    memory: { v2: { enabled: flagsState.configV2Enabled } },
+    memory: { v2: { enabled: configState.v2Enabled } },
   }),
   getConfigReadOnly: () => ({
-    memory: { v2: { enabled: flagsState.configV2Enabled } },
+    memory: { v2: { enabled: configState.v2Enabled } },
   }),
   loadConfig: () => ({
-    memory: { v2: { enabled: flagsState.configV2Enabled } },
+    memory: { v2: { enabled: configState.v2Enabled } },
   }),
   invalidateConfigCache: () => {},
   loadRawConfig: () => ({}),
@@ -147,9 +131,11 @@ mock.module("../skills/catalog-cache.js", () => ({
 }));
 
 mock.module("../skills/catalog-install.js", () => ({
-  installSkillLocally: async () => {},
-  upsertSkillsIndex: () => {},
+  commitStagedSkillInstall: () => {},
+  createSkillInstallStagingDir: () => "/tmp/test-skills/.install-staging/test",
   getRepoSkillsDir: () => undefined,
+  installSkillDependenciesIfPresent: () => {},
+  installSkillLocally: async () => {},
 }));
 
 mock.module("../skills/catalog-search.js", () => ({
@@ -159,23 +145,15 @@ mock.module("../skills/catalog-search.js", () => ({
 mock.module("../skills/managed-store.js", () => ({
   createManagedSkill: () => ({ created: true }),
   deleteManagedSkill: () => ({ deleted: true }),
-  removeSkillsIndexEntry: () => {},
   validateManagedSkillId: () => null,
 }));
 
 mock.module("../memory/graph/capability-seed.js", () => ({
   deleteSkillCapabilityNode: () => {},
-  seedSkillGraphNodes: mockSeedSkillGraphNodes,
-  seedUninstalledCatalogSkillMemories: async () => {},
-}));
-
-mock.module("../memory/v2/skill-store.js", () => ({
-  seedV2SkillEntries: mock(async () => {}),
-  getSkillCapability: () => null,
 }));
 
-mock.module("../daemon/memory-v2-startup.js", () => ({
-  maybeSeedMemoryV2Skills: mockMaybeSeedMemoryV2Skills,
+mock.module("../daemon/skill-memory-refresh.js", () => ({
+  refreshSkillCapabilityMemories: mockRefreshSkillCapabilityMemories,
 }));
 
 mock.module("../util/platform.js", () => ({
@@ -204,45 +182,48 @@ mock.module("../daemon/config-watcher.js", () => ({
 }));
 
 // Import after mocking
-const { installSkill } = await import("../daemon/handlers/skills.js");
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
+const { installSkill, uninstallSkill } =
+  await import("../daemon/handlers/skills.js");
 
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
 
-describe("v2 skill re-seed gating in skill handlers", () => {
+describe("v2 skill refresh delegation in skill handlers", () => {
   beforeEach(() => {
-    flagsState.configV2Enabled = true;
-    callOrder.length = 0;
-    mockSeedSkillGraphNodes.mockClear();
-    mockMaybeSeedMemoryV2Skills.mockClear();
-    mockMaybeSeedMemoryV2Skills.mockImplementation((config) => {
-      if (!config.memory.v2.enabled) return;
-      callOrder.push("v2");
-    });
+    configState.v2Enabled = true;
+    mockRefreshSkillCapabilityMemories.mockClear();
   });
 
-  test("config on → maybeSeedMemoryV2Skills invoked after seedSkillGraphNodes", async () => {
+  test("enabled config → refresh helper invoked with live config", async () => {
     const result = await installSkill({ slug: "bundled-skill" });
 
     expect(result.success).toBe(true);
-    expect(mockSeedSkillGraphNodes).toHaveBeenCalledTimes(1);
-    expect(mockMaybeSeedMemoryV2Skills).toHaveBeenCalledTimes(1);
-    expect(callOrder).toEqual(["v1", "v2"]);
+    expect(mockRefreshSkillCapabilityMemories).toHaveBeenCalledTimes(1);
+    expect(mockRefreshSkillCapabilityMemories.mock.calls[0]?.[0]).toEqual({
+      memory: { v2: { enabled: true } },
+    });
   });
 
-  test("config.memory.v2.enabled off → seed mock observes config and skips", async () => {
-    flagsState.configV2Enabled = false;
+  test("config.memory.v2.enabled off → helper receives disabled config", async () => {
+    configState.v2Enabled = false;
 
     const result = await installSkill({ slug: "bundled-skill" });
 
     expect(result.success).toBe(true);
-    expect(mockSeedSkillGraphNodes).toHaveBeenCalledTimes(1);
-    expect(mockMaybeSeedMemoryV2Skills).toHaveBeenCalledTimes(1);
-    expect(callOrder).toEqual(["v1"]);
+    expect(mockRefreshSkillCapabilityMemories).toHaveBeenCalledTimes(1);
+    expect(mockRefreshSkillCapabilityMemories.mock.calls[0]?.[0]).toEqual({
+      memory: { v2: { enabled: false } },
+    });
+  });
+
+  test("uninstall delegates to refresh helper", async () => {
+    const result = await uninstallSkill("managed-skill");
+
+    expect(result.success).toBe(true);
+    expect(mockRefreshSkillCapabilityMemories).toHaveBeenCalledTimes(1);
+    expect(mockRefreshSkillCapabilityMemories.mock.calls[0]?.[0]).toEqual({
+      memory: { v2: { enabled: true } },
+    });
   });
 });