convex 1.34.0 → 1.35.0

package/src/cli/lib/{ai → aiFiles}/integration.test.ts

@@ -3,13 +3,12 @@ import fs from "fs";
 import os from "os";
 import path from "path";
 import {
-  checkAiFilesStaleness,
-  disableAiFiles,
+  checkAiFilesStalenessAndLog,
   enableAiFiles,
   removeAiFiles,
-  statusAiFiles,
-  updateAiFiles,
+  installAiFiles,
 } from "./index.js";
+import { statusAiFiles } from "./status.js";
 import { logMessage } from "../../../bundler/log.js";
 import { AGENTS_MD_START_MARKER } from "../../codegen_templates/agentsmd.js";
 import { CLAUDE_MD_START_MARKER } from "../../codegen_templates/claudemd.js";
@@ -22,10 +21,13 @@ vi.mock("../versionApi.js", () => ({
   downloadGuidelines: vi.fn(async () => "integration guidelines content"),
   fetchAgentSkillsSha: vi.fn(async () => "integration-sha"),
   getVersion: vi.fn(async () => ({
-    message: null,
-    guidelinesHash: "integration-guidelines-hash",
-    agentSkillsSha: "integration-agent-skills-sha",
-    disableSkillsCli: false,
+    kind: "ok",
+    data: {
+      message: null,
+      guidelinesHash: "integration-guidelines-hash",
+      agentSkillsSha: "integration-agent-skills-sha",
+      disableSkillsCli: false,
+    },
   })),
 }));
 
@@ -43,6 +45,8 @@ vi.mock("child_process", () => ({
   },
 }));
 
+import child_process from "child_process";
+
 // ---------------------------------------------------------------------------
 // Shared helpers
 // ---------------------------------------------------------------------------
@@ -51,6 +55,16 @@ function readJson(filePath: string): any {
   return JSON.parse(fs.readFileSync(filePath, "utf8"));
 }
 
+function patchConvexJson(projectDir: string, patch: object) {
+  const filePath = path.join(projectDir, "convex.json");
+  const existing = fs.existsSync(filePath) ? readJson(filePath) : {};
+  fs.writeFileSync(
+    filePath,
+    JSON.stringify({ ...existing, ...patch }, null, 2) + "\n",
+    "utf8",
+  );
+}
+
 function makeTmpDir(): string {
   return fs.mkdtempSync(`${os.tmpdir()}${path.sep}`);
 }
@@ -80,7 +94,7 @@ describe("ai-files integration with default convex/ directory", () => {
   });
 
   test("install creates guidelines, state, AGENTS.md, and CLAUDE.md", async () => {
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
 
     expect(fs.existsSync(guidelinesPath())).toBe(true);
     expect(fs.existsSync(statePath())).toBe(true);
@@ -89,6 +103,55 @@ describe("ai-files integration with default convex/ directory", () => {
     expect(fs.readFileSync(guidelinesPath(), "utf8")).toBe(
       "integration guidelines content",
     );
+
+    // Default agents
+    expect(vi.mocked(child_process.spawn)).toHaveBeenCalledWith(
+      "npx",
+      expect.arrayContaining([
+        "add",
+        "get-convex/agent-skills",
+        "--yes",
+        "--agent",
+        "claude-code",
+        "--agent",
+        "codex",
+      ]),
+      expect.any(Object),
+    );
+  });
+
+  test("install respects explicit agent configuration", async () => {
+    await installAiFiles({
+      projectDir: tmpDir,
+      convexDir,
+      aiFilesConfig: { skills: { agents: ["cursor", "windsurf"] } },
+    });
+
+    expect(vi.mocked(child_process.spawn)).toHaveBeenCalledWith(
+      "npx",
+      expect.arrayContaining([
+        "add",
+        "get-convex/agent-skills",
+        "--yes",
+        "--agent",
+        "cursor",
+        "--agent",
+        "windsurf",
+      ]),
+      expect.any(Object),
+    );
+  });
+
+  test("install skips skills CLI when configured agents are empty", async () => {
+    await installAiFiles({
+      projectDir: tmpDir,
+      convexDir,
+      aiFilesConfig: { skills: { agents: [] } },
+    });
+
+    expect(fs.existsSync(guidelinesPath())).toBe(true);
+    expect(fs.existsSync(statePath())).toBe(true);
+    expect(vi.mocked(child_process.spawn)).not.toHaveBeenCalled();
   });
 
   test("preserves existing AGENTS.md content and injects managed section", async () => {
@@ -96,7 +159,7 @@ describe("ai-files integration with default convex/ directory", () => {
       path.join(tmpDir, "AGENTS.md"),
       "# My Project\n\nImportant team guidelines here.\n",
     );
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
     const content = fs.readFileSync(path.join(tmpDir, "AGENTS.md"), "utf8");
     expect(content).toContain("# My Project");
     expect(content).toContain("Important team guidelines here.");
@@ -111,17 +174,17 @@ describe("ai-files integration with default convex/ directory", () => {
       path.join(tmpDir, "CLAUDE.md"),
       "My custom CLAUDE.md content\n",
     );
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
     const content = fs.readFileSync(path.join(tmpDir, "CLAUDE.md"), "utf8");
     expect(content).toContain("My custom CLAUDE.md content");
   });
 
   test("second update is idempotent", async () => {
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
     const firstGuidelines = fs.readFileSync(guidelinesPath(), "utf8");
     const firstState = fs.readFileSync(statePath(), "utf8");
 
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
 
     expect(fs.readFileSync(guidelinesPath(), "utf8")).toBe(firstGuidelines);
     expect(fs.readFileSync(statePath(), "utf8")).toBe(firstState);
@@ -133,93 +196,61 @@ describe("ai-files integration with default convex/ directory", () => {
       path.join(tmpDir, ".cursor", "rules", "convex_rules.mdc"),
       "legacy",
     );
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
     expect(
       fs.existsSync(path.join(tmpDir, ".cursor", "rules", "convex_rules.mdc")),
     ).toBe(false);
   });
 
-  test("skips locally modified guidelines", async () => {
-    await updateAiFiles(tmpDir, convexDir);
-    fs.appendFileSync(guidelinesPath(), "\n## My custom note\n");
-    const state = readJson(statePath());
-    state.guidelinesHash = "deliberately-stale-hash";
-    fs.writeFileSync(statePath(), JSON.stringify(state, null, 2) + "\n");
-
-    await updateAiFiles(tmpDir, convexDir);
-
-    expect(fs.readFileSync(guidelinesPath(), "utf8")).toContain(
-      "My custom note",
-    );
-    expect(vi.mocked(logMessage)).toHaveBeenCalledWith(
-      expect.stringContaining("modified locally"),
-    );
-  });
-
   test("staleness check nags when stored hash is stale", async () => {
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
     const state = readJson(statePath());
     state.guidelinesHash = "deliberately-stale-hash";
     fs.writeFileSync(statePath(), JSON.stringify(state, null, 2) + "\n");
 
-    await checkAiFilesStaleness("canonical-hash", null, tmpDir, convexDir);
+    await checkAiFilesStalenessAndLog({
+      canonicalGuidelinesHash: "canonical-hash",
+      canonicalAgentSkillsSha: null,
+      projectDir: tmpDir,
+      convexDir,
+    });
 
     expect(vi.mocked(logMessage)).toHaveBeenCalledWith(
       expect.stringContaining("out of date"),
     );
   });
 
-  test("staleness check is silent when disabled in convex.json", async () => {
-    await updateAiFiles(tmpDir, convexDir);
-    await disableAiFiles(tmpDir);
-    const state = readJson(statePath());
-    state.guidelinesHash = "deliberately-stale-hash";
-    fs.writeFileSync(statePath(), JSON.stringify(state, null, 2) + "\n");
-    vi.mocked(logMessage).mockClear();
-
-    await checkAiFilesStaleness("canonical-hash", null, tmpDir, convexDir);
-
-    const calls = vi.mocked(logMessage).mock.calls.map((c) => c[0]);
-    expect(
-      calls.find((m) => typeof m === "string" && m.includes("out of date")),
-    ).toBeUndefined();
-  });
-
   test("disable keeps files but sets convex.json preference", async () => {
-    await updateAiFiles(tmpDir, convexDir);
-    await disableAiFiles(tmpDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
+    patchConvexJson(tmpDir, { aiFiles: { enabled: false } });
 
-    expect(readJson(projectConfigPath()).aiFiles.disableStalenessMessage).toBe(
-      true,
-    );
+    expect(readJson(projectConfigPath()).aiFiles.enabled).toBe(false);
     expect(fs.existsSync(guidelinesPath())).toBe(true);
     expect(fs.existsSync(path.join(tmpDir, "AGENTS.md"))).toBe(true);
     expect(fs.existsSync(path.join(tmpDir, "CLAUDE.md"))).toBe(true);
   });
 
   test("disable before install writes only convex.json and no AI state file", async () => {
-    await disableAiFiles(tmpDir);
+    patchConvexJson(tmpDir, { aiFiles: { enabled: false } });
 
-    expect(readJson(projectConfigPath()).aiFiles.disableStalenessMessage).toBe(
-      true,
-    );
+    expect(readJson(projectConfigPath()).aiFiles.enabled).toBe(false);
     expect(fs.existsSync(statePath())).toBe(false);
     expect(fs.existsSync(guidelinesPath())).toBe(false);
   });
 
   test("remove deletes ai directory and AGENTS.md managed section", async () => {
-    await updateAiFiles(tmpDir, convexDir);
-    await removeAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
+    await removeAiFiles({ projectDir: tmpDir, convexDir });
 
     expect(fs.existsSync(aiDir())).toBe(false);
   });
 
   test("status reports not installed after remove", async () => {
-    await updateAiFiles(tmpDir, convexDir);
-    await removeAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
+    await removeAiFiles({ projectDir: tmpDir, convexDir });
     vi.mocked(logMessage).mockClear();
 
-    await statusAiFiles(tmpDir, convexDir);
+    await statusAiFiles({ projectDir: tmpDir, convexDir });
 
     expect(vi.mocked(logMessage)).toHaveBeenCalledWith(
       expect.stringContaining("not installed"),
@@ -227,10 +258,10 @@ describe("ai-files integration with default convex/ directory", () => {
   });
 
   test("status reports installed and enabled after install", async () => {
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
     vi.mocked(logMessage).mockClear();
 
-    await statusAiFiles(tmpDir, convexDir);
+    await statusAiFiles({ projectDir: tmpDir, convexDir });
 
     expect(vi.mocked(logMessage)).toHaveBeenCalledWith(
       expect.stringContaining("enabled"),
@@ -238,52 +269,60 @@ describe("ai-files integration with default convex/ directory", () => {
   });
 
   test("disable after CLAUDE.md user edits preserves the file", async () => {
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
     fs.appendFileSync(path.join(tmpDir, "CLAUDE.md"), "My custom note\n");
-    await disableAiFiles(tmpDir);
+    patchConvexJson(tmpDir, { aiFiles: { enabled: false } });
     expect(fs.readFileSync(path.join(tmpDir, "CLAUDE.md"), "utf8")).toContain(
       "My custom note",
     );
   });
 
   test("update recreates missing CLAUDE.md", async () => {
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
     fs.rmSync(path.join(tmpDir, "CLAUDE.md"), { force: true });
 
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
 
     expect(fs.readFileSync(path.join(tmpDir, "CLAUDE.md"), "utf8")).toContain(
       "convex/_generated/ai/guidelines.md",
     );
   });
 
-  test("enable clears disableStalenessMessage", async () => {
-    await updateAiFiles(tmpDir, convexDir);
-    await disableAiFiles(tmpDir);
+  test("enable sets enabled flag to true and strips deprecated disableStalenessMessage", async () => {
+    await installAiFiles({ projectDir: tmpDir, convexDir });
+    patchConvexJson(tmpDir, { aiFiles: { disableStalenessMessage: true } });
     expect(readJson(projectConfigPath()).aiFiles.disableStalenessMessage).toBe(
       true,
     );
 
-    await enableAiFiles(tmpDir, convexDir);
+    const newAiFiles = await enableAiFiles({
+      projectDir: tmpDir,
+      convexDir,
+      aiFilesConfig: readJson(projectConfigPath()).aiFiles,
+    });
+    patchConvexJson(tmpDir, { aiFiles: newAiFiles });
 
-    expect(readJson(projectConfigPath()).aiFiles.disableStalenessMessage).toBe(
-      false,
-    );
+    const updatedConfig = readJson(projectConfigPath());
+    expect(updatedConfig.aiFiles.enabled).toBe(true);
+    expect(updatedConfig.aiFiles.disableStalenessMessage).toBeUndefined();
   });
 
   test("full cycle: disable -> remove -> enable reinstalls everything", async () => {
-    await updateAiFiles(tmpDir, convexDir);
-    await disableAiFiles(tmpDir);
-    await removeAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
+    patchConvexJson(tmpDir, { aiFiles: { enabled: false } });
+    await removeAiFiles({ projectDir: tmpDir, convexDir });
     expect(fs.existsSync(aiDir())).toBe(false);
 
-    await enableAiFiles(tmpDir, convexDir);
+    const newAiFiles = await enableAiFiles({
+      projectDir: tmpDir,
+      convexDir,
+      aiFilesConfig: readJson(projectConfigPath()).aiFiles,
+    });
+    patchConvexJson(tmpDir, { aiFiles: newAiFiles });
 
     expect(fs.existsSync(guidelinesPath())).toBe(true);
     expect(fs.existsSync(path.join(tmpDir, "AGENTS.md"))).toBe(true);
-    expect(readJson(projectConfigPath()).aiFiles.disableStalenessMessage).toBe(
-      false,
-    );
+    expect(readJson(projectConfigPath()).aiFiles.enabled).toBe(true);
   });
 
   test("remove strips managed section from AGENTS.md but preserves user content", async () => {
@@ -291,11 +330,11 @@ describe("ai-files integration with default convex/ directory", () => {
       path.join(tmpDir, "AGENTS.md"),
       "# My Project\n\nTeam guidelines here.\n",
     );
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
     const before = fs.readFileSync(path.join(tmpDir, "AGENTS.md"), "utf8");
     expect(before).toContain(AGENTS_MD_START_MARKER);
 
-    await removeAiFiles(tmpDir, convexDir);
+    await removeAiFiles({ projectDir: tmpDir, convexDir });
 
     const after = fs.readFileSync(path.join(tmpDir, "AGENTS.md"), "utf8");
     expect(after).toContain("# My Project");
@@ -304,19 +343,19 @@ describe("ai-files integration with default convex/ directory", () => {
   });
 
   test("remove on AGENTS.md with only Convex content deletes the file", async () => {
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
     expect(fs.existsSync(path.join(tmpDir, "AGENTS.md"))).toBe(true);
 
-    await removeAiFiles(tmpDir, convexDir);
+    await removeAiFiles({ projectDir: tmpDir, convexDir });
 
     expect(fs.existsSync(path.join(tmpDir, "AGENTS.md"))).toBe(false);
   });
 
   test("remove deletes CLAUDE.md when empty after stripping managed section", async () => {
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
     expect(fs.existsSync(path.join(tmpDir, "CLAUDE.md"))).toBe(true);
 
-    await removeAiFiles(tmpDir, convexDir);
+    await removeAiFiles({ projectDir: tmpDir, convexDir });
 
     expect(fs.existsSync(path.join(tmpDir, "CLAUDE.md"))).toBe(false);
   });
@@ -326,11 +365,11 @@ describe("ai-files integration with default convex/ directory", () => {
       path.join(tmpDir, "CLAUDE.md"),
       "My project-specific Claude instructions\n",
     );
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
     const before = fs.readFileSync(path.join(tmpDir, "CLAUDE.md"), "utf8");
     expect(before).toContain(CLAUDE_MD_START_MARKER);
 
-    await removeAiFiles(tmpDir, convexDir);
+    await removeAiFiles({ projectDir: tmpDir, convexDir });
 
     const after = fs.readFileSync(path.join(tmpDir, "CLAUDE.md"), "utf8");
     expect(after).toContain("My project-specific Claude instructions");
@@ -340,7 +379,12 @@ describe("ai-files integration with default convex/ directory", () => {
   test("checkAiFilesStaleness nags when no state file exists", async () => {
     vi.mocked(logMessage).mockClear();
 
-    await checkAiFilesStaleness(null, null, tmpDir, convexDir);
+    await checkAiFilesStalenessAndLog({
+      canonicalGuidelinesHash: null,
+      canonicalAgentSkillsSha: null,
+      projectDir: tmpDir,
+      convexDir,
+    });
 
     expect(vi.mocked(logMessage)).toHaveBeenCalledWith(
       expect.stringContaining("not installed"),
@@ -348,16 +392,16 @@ describe("ai-files integration with default convex/ directory", () => {
   });
 
   test("checkAiFilesStaleness is silent when hashes match", async () => {
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
     const state = readJson(statePath());
     vi.mocked(logMessage).mockClear();
 
-    await checkAiFilesStaleness(
-      state.guidelinesHash,
-      state.agentSkillsSha,
-      tmpDir,
+    await checkAiFilesStalenessAndLog({
+      canonicalGuidelinesHash: state.guidelinesHash,
+      canonicalAgentSkillsSha: state.agentSkillsSha,
+      projectDir: tmpDir,
       convexDir,
-    );
+    });
 
     const calls = vi.mocked(logMessage).mock.calls.map((c) => c[0]);
     expect(
@@ -369,9 +413,9 @@ describe("ai-files integration with default convex/ directory", () => {
   });
 
   test("AGENTS.md managed section is replaced not duplicated on repeated updates", async () => {
-    await updateAiFiles(tmpDir, convexDir);
-    await updateAiFiles(tmpDir, convexDir);
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
+    await installAiFiles({ projectDir: tmpDir, convexDir });
+    await installAiFiles({ projectDir: tmpDir, convexDir });
 
     const content = fs.readFileSync(path.join(tmpDir, "AGENTS.md"), "utf8");
     const markerCount = content.split(AGENTS_MD_START_MARKER).length - 1;
@@ -379,11 +423,15 @@ describe("ai-files integration with default convex/ directory", () => {
   });
 
   test("status reports disabled state after disable", async () => {
-    await updateAiFiles(tmpDir, convexDir);
-    await disableAiFiles(tmpDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
+    patchConvexJson(tmpDir, { aiFiles: { enabled: false } });
     vi.mocked(logMessage).mockClear();
 
-    await statusAiFiles(tmpDir, convexDir);
+    await statusAiFiles({
+      projectDir: tmpDir,
+      convexDir,
+      aiFilesConfig: readJson(projectConfigPath()).aiFiles,
+    });
 
     expect(vi.mocked(logMessage)).toHaveBeenCalledWith(
       expect.stringContaining("disabled"),
@@ -421,7 +469,7 @@ describe("ai-files integration with functions directory override", () => {
   });
 
   test("installs into overridden functions directory, not default convex/", async () => {
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
 
     expect(fs.existsSync(guidelinesPath())).toBe(true);
     expect(fs.existsSync(statePath())).toBe(true);
@@ -440,7 +488,7 @@ describe("ai-files integration with functions directory override", () => {
       path.join(tmpDir, "AGENTS.md"),
       "# Existing\n\nUser content.\n",
     );
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
     const content = fs.readFileSync(path.join(tmpDir, "AGENTS.md"), "utf8");
     expect(content).toContain("# Existing");
     expect(content).toContain("User content.");
@@ -456,17 +504,17 @@ describe("ai-files integration with functions directory override", () => {
       "My custom CLAUDE.md content\n",
       "utf8",
     );
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
     const content = fs.readFileSync(path.join(tmpDir, "CLAUDE.md"), "utf8");
     expect(content).toContain("My custom CLAUDE.md content");
   });
 
   test("second update is idempotent", async () => {
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
     const firstGuidelines = fs.readFileSync(guidelinesPath(), "utf8");
     const firstState = fs.readFileSync(statePath(), "utf8");
 
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
 
     expect(fs.readFileSync(guidelinesPath(), "utf8")).toBe(firstGuidelines);
     expect(fs.readFileSync(statePath(), "utf8")).toBe(firstState);
@@ -479,36 +527,14 @@ describe("ai-files integration with functions directory override", () => {
       "legacy",
       "utf8",
     );
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
     expect(
       fs.existsSync(path.join(tmpDir, ".cursor", "rules", "convex_rules.mdc")),
     ).toBe(false);
   });
 
-  test("skips locally modified guidelines when stored hash is stale", async () => {
-    await updateAiFiles(tmpDir, convexDir);
-    const localNote = "\n## My custom note\n";
-    fs.appendFileSync(guidelinesPath(), localNote, "utf8");
-    const state = readJson(statePath());
-    state.guidelinesHash = "deliberately-stale-hash";
-    fs.writeFileSync(
-      statePath(),
-      JSON.stringify(state, null, 2) + "\n",
-      "utf8",
-    );
-
-    await updateAiFiles(tmpDir, convexDir);
-
-    expect(fs.readFileSync(guidelinesPath(), "utf8")).toContain(
-      localNote.trim(),
-    );
-    expect(vi.mocked(logMessage)).toHaveBeenCalledWith(
-      expect.stringContaining("modified locally"),
-    );
-  });
-
   test("staleness check logs update nag for stale stored hash", async () => {
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
     const state = readJson(statePath());
     state.guidelinesHash = "deliberately-stale-hash";
     fs.writeFileSync(
@@ -517,7 +543,12 @@ describe("ai-files integration with functions directory override", () => {
       "utf8",
     );
 
-    await checkAiFilesStaleness("canonical-hash", null, tmpDir, convexDir);
+    await checkAiFilesStalenessAndLog({
+      canonicalGuidelinesHash: "canonical-hash",
+      canonicalAgentSkillsSha: null,
+      projectDir: tmpDir,
+      convexDir,
+    });
 
     expect(vi.mocked(logMessage)).toHaveBeenCalledWith(
       expect.stringContaining("out of date"),
@@ -525,21 +556,19 @@ describe("ai-files integration with functions directory override", () => {
   });
 
   test("disable sets convex.json preference and keeps files", async () => {
-    await updateAiFiles(tmpDir, convexDir);
-    await disableAiFiles(tmpDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
+    patchConvexJson(tmpDir, { aiFiles: { enabled: false } });
 
-    expect(readJson(projectConfigPath()).aiFiles.disableStalenessMessage).toBe(
-      true,
-    );
+    expect(readJson(projectConfigPath()).aiFiles.enabled).toBe(false);
     expect(fs.existsSync(guidelinesPath())).toBe(true);
     expect(fs.existsSync(path.join(tmpDir, "AGENTS.md"))).toBe(true);
     expect(fs.existsSync(path.join(tmpDir, "CLAUDE.md"))).toBe(true);
   });
 
   test("remove deletes files and status reports not installed", async () => {
-    await updateAiFiles(tmpDir, convexDir);
-    await removeAiFiles(tmpDir, convexDir);
-    await statusAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
+    await removeAiFiles({ projectDir: tmpDir, convexDir });
+    await statusAiFiles({ projectDir: tmpDir, convexDir });
 
     expect(fs.existsSync(aiDir())).toBe(false);
     expect(vi.mocked(logMessage)).toHaveBeenCalledWith(
@@ -548,23 +577,23 @@ describe("ai-files integration with functions directory override", () => {
   });
 
   test("disable after CLAUDE.md user edits preserves file", async () => {
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
     fs.appendFileSync(
       path.join(tmpDir, "CLAUDE.md"),
       "My custom note\n",
       "utf8",
     );
-    await disableAiFiles(tmpDir);
+    patchConvexJson(tmpDir, { aiFiles: { enabled: false } });
     expect(fs.readFileSync(path.join(tmpDir, "CLAUDE.md"), "utf8")).toContain(
       "My custom note",
     );
   });
 
   test("update recreates missing CLAUDE.md", async () => {
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
     fs.rmSync(path.join(tmpDir, "CLAUDE.md"), { force: true });
 
-    await updateAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
 
     const content = fs.readFileSync(path.join(tmpDir, "CLAUDE.md"), "utf8");
     expect(content).toMatch(
@@ -572,30 +601,38 @@ describe("ai-files integration with functions directory override", () => {
     );
   });
 
-  test("enable clears disableStalenessMessage and re-enables status", async () => {
-    await updateAiFiles(tmpDir, convexDir);
-    await disableAiFiles(tmpDir);
-    await enableAiFiles(tmpDir, convexDir);
-    await statusAiFiles(tmpDir, convexDir);
+  test("enable sets enabled flag to true and re-enables status", async () => {
+    await installAiFiles({ projectDir: tmpDir, convexDir });
+    patchConvexJson(tmpDir, { aiFiles: { enabled: false } });
+    const newAiFiles = await enableAiFiles({
+      projectDir: tmpDir,
+      convexDir,
+      aiFilesConfig: readJson(projectConfigPath()).aiFiles,
+    });
+    patchConvexJson(tmpDir, { aiFiles: newAiFiles });
+    await statusAiFiles({ projectDir: tmpDir, convexDir });
 
-    expect(readJson(projectConfigPath()).aiFiles.disableStalenessMessage).toBe(
-      false,
-    );
+    expect(readJson(projectConfigPath()).aiFiles.enabled).toBe(true);
     expect(vi.mocked(logMessage)).toHaveBeenCalledWith(
       expect.stringContaining("enabled"),
     );
   });
 
   test("disable + remove + enable works with overridden functions directory", async () => {
-    await updateAiFiles(tmpDir, convexDir);
-    await disableAiFiles(tmpDir);
-    await removeAiFiles(tmpDir, convexDir);
+    await installAiFiles({ projectDir: tmpDir, convexDir });
+    patchConvexJson(tmpDir, { aiFiles: { enabled: false } });
+    await removeAiFiles({ projectDir: tmpDir, convexDir });
 
     expect(
       fs.existsSync(path.join(tmpDir, "src", "convex", "_generated", "ai")),
     ).toBe(false);
 
-    await enableAiFiles(tmpDir, convexDir);
+    const newAiFiles = await enableAiFiles({
+      projectDir: tmpDir,
+      convexDir,
+      aiFilesConfig: readJson(projectConfigPath()).aiFiles,
+    });
+    patchConvexJson(tmpDir, { aiFiles: newAiFiles });
 
     expect(fs.existsSync(guidelinesPath())).toBe(true);
   });