convex 1.34.1 → 1.35.0

package/src/cli/lib/aiFiles/index.ts

@@ -12,25 +12,26 @@ import {
   hasGuidelinesInstalled,
 } from "./guidelinesmd.js";
 import {
-  type AiFilesConfig,
-  hasAiFilesConfig,
-  readAiConfig,
-  writeAiConfig,
-  writeAiEnabledToProjectConfig,
-} from "./config.js";
-import { isInInteractiveTerminal } from "./utils.js";
+  attemptReadAiState,
+  readAiStateOrDefault,
+  writeAiState,
+  hasAiState,
+} from "./state.js";
+import { type AiFilesProjectConfig } from "../config.js";
+import { exhaustiveCheck, isInInteractiveTerminal } from "./utils.js";
 import {
   hasAgentsMdInstalled,
   applyAgentsMdSection,
-  removeAgentsMdSection,
+  attemptToRemoveAgentsMdSection,
 } from "./agentsmd.js";
 import {
   hasClaudeMdInstalled,
   applyClaudeMdSection,
-  removeClaudeMdSection,
+  attemptToRemoveClaudeMdSection,
 } from "./claudemd.js";
 import { installSkills, removeInstalledSkills } from "./skills.js";
 import { removeLegacyCursorRulesFile as removeLegacyCursorRules } from "./cursorrules.js";
+
 async function hasExistingAiFilesArtifacts({
   projectDir,
   convexDir,
@@ -45,53 +46,25 @@ async function hasExistingAiFilesArtifacts({
 /**
  * Install or refresh all Convex AI files.
  *
- * Reads the existing config if present, or starts from a blank one for a
- * fresh install. Each component can be individually skipped via the optional
- * flags (all default to true).
+ * Reads the existing state if present, or starts from a blank one for a
+ * fresh install.
  */
 export async function installAiFiles({
   projectDir,
   convexDir,
-  shouldWriteGuidelines = true,
-  shouldWriteAgentsMd = true,
-  shouldWriteClaudeMd = true,
-  shouldWriteSkills = true,
+  aiFilesConfig,
 }: AiFilesPaths & {
-  shouldWriteGuidelines?: boolean;
-  shouldWriteAgentsMd?: boolean;
-  shouldWriteClaudeMd?: boolean;
-  shouldWriteSkills?: boolean;
+  aiFilesConfig?: AiFilesProjectConfig | undefined;
 }): Promise<void> {
-  await fs.mkdir(aiDirForConvexDir(convexDir), { recursive: true });
-
-  const config: AiFilesConfig = (await readAiConfig({
-    projectDir,
-    convexDir,
-  })) ?? {
-    enabled: true,
-    guidelinesHash: null,
-    agentsMdSectionHash: null,
-    claudeMdHash: null,
-    agentSkillsSha: null,
-    installedSkillNames: [],
-  };
-
-  if (shouldWriteGuidelines) await installGuidelinesFile({ convexDir, config });
-
   const convexDirName = path.relative(projectDir, convexDir);
+  const state = await readAiStateOrDefault(convexDir);
 
-  if (shouldWriteAgentsMd)
-    await applyAgentsMdSection({ projectDir, config, convexDirName });
-
-  if (shouldWriteClaudeMd)
-    await applyClaudeMdSection({ projectDir, config, convexDirName });
-
-  if (shouldWriteSkills) await installSkills({ projectDir, config });
-
+  await installGuidelinesFile({ convexDir, state });
+  await applyAgentsMdSection({ projectDir, state, convexDirName });
+  await applyClaudeMdSection({ projectDir, state, convexDirName });
+  await installSkills({ projectDir, state, aiFilesConfig });
   await removeLegacyCursorRules(projectDir);
-  await writeAiConfig({ config, projectDir, convexDir });
-
-  logMessage(`${chalkStderr.green("✔")} Convex AI files installed.`);
+  await writeAiState({ state, convexDir });
 }
 
 async function attemptToInstallAiFiles(
@@ -104,58 +77,70 @@ async function attemptToInstallAiFiles(
   }
 }
 
-type AiFilesStalenessStatus =
-  | "not-installed" // no config AND no artifacts — show install nag
-  | "has-artifacts" // no config but files exist on disk (e.g. fresh checkout) — stay quiet
-  | "disabled" // user opted out of nag messages
-  | "stale" // one or more files are out of date
-  | "up-to-date"; // everything looks fine
+type AiFilesStalenessStatus = "not-installed" | "stale" | "silent";
+
+export function isAiFilesDisabled(
+  aiFilesConfig: AiFilesProjectConfig | undefined,
+): boolean {
+  if (aiFilesConfig?.enabled !== undefined)
+    return aiFilesConfig.enabled === false;
+  return aiFilesConfig?.disableStalenessMessage === true;
+}
 
 async function determineAiFilesStaleness({
   canonicalGuidelinesHash,
   canonicalAgentSkillsSha,
+  aiFilesConfig,
   projectDir,
   convexDir,
 }: {
   canonicalGuidelinesHash: string | null;
   canonicalAgentSkillsSha: string | null;
+  aiFilesConfig?: AiFilesProjectConfig | undefined;
 } & AiFilesPaths): Promise<AiFilesStalenessStatus> {
-  const config = await readAiConfig({ projectDir, convexDir });
+  if (isAiFilesDisabled(aiFilesConfig)) return "silent";
+
+  const result = await attemptReadAiState(convexDir);
 
-  if (config === null) {
+  if (result.kind === "no-file" || result.kind === "parse-error") {
     const hasArtifacts = await hasExistingAiFilesArtifacts({
       projectDir,
       convexDir,
     });
-    return hasArtifacts ? "has-artifacts" : "not-installed";
+    return hasArtifacts ? "silent" : "not-installed";
   }
 
-  if (!config.enabled) return "disabled";
+  if (result.kind === "ok") {
+    const { state } = result;
+
+    if (canonicalGuidelinesHash === null && canonicalAgentSkillsSha === null)
+      return "silent";
 
-  if (canonicalGuidelinesHash === null && canonicalAgentSkillsSha === null)
-    return "up-to-date";
+    const guidelinesStale =
+      canonicalGuidelinesHash !== null &&
+      state.guidelinesHash !== null &&
+      state.guidelinesHash !== canonicalGuidelinesHash;
 
-  const guidelinesStale =
-    canonicalGuidelinesHash !== null &&
-    config.guidelinesHash !== null &&
-    config.guidelinesHash !== canonicalGuidelinesHash;
+    const skillsStale =
+      canonicalAgentSkillsSha !== null &&
+      state.agentSkillsSha !== null &&
+      state.agentSkillsSha !== canonicalAgentSkillsSha;
 
-  const skillsStale =
-    canonicalAgentSkillsSha !== null &&
-    config.agentSkillsSha !== null &&
-    config.agentSkillsSha !== canonicalAgentSkillsSha;
+    return guidelinesStale || skillsStale ? "stale" : "silent";
+  }
 
-  return guidelinesStale || skillsStale ? "stale" : "up-to-date";
+  return exhaustiveCheck(result);
 }
 
 /**
  * Check whether the Convex AI files are out of date and log a nag message
  * if so.
  */
-export async function checkAiFilesStaleness(
+export async function checkAiFilesStalenessAndLog(
   opts: {
     canonicalGuidelinesHash: string | null;
     canonicalAgentSkillsSha: string | null;
+    aiFilesConfig?: AiFilesProjectConfig | undefined;
   } & AiFilesPaths,
 ): Promise<void> {
   const status = await determineAiFilesStaleness(opts);
@@ -166,6 +151,7 @@ export async function checkAiFilesStaleness(
         `Convex AI files are not installed. Run ${chalkStderr.bold(`npx convex ai-files install`)} to get started or ${chalkStderr.bold(`npx convex ai-files disable`)} to hide this message.`,
       ),
     );
+    return;
   }
 
   if (status === "stale") {
@@ -174,23 +160,39 @@ export async function checkAiFilesStaleness(
         `Your Convex AI files are out of date. Run ${chalkStderr.bold(`npx convex ai-files update`)} to get the latest.`,
       ),
     );
+    return;
   }
+
+  if (status === "silent") return;
+
+  exhaustiveCheck(status);
 }
 
+/**
+ * Installs AI files and returns the aiFiles config to write.
+ */
 export async function enableAiFiles({
   projectDir,
   convexDir,
-}: AiFilesPaths): Promise<void> {
-  await installAiFiles({ projectDir, convexDir });
-  const config = await readAiConfig({ projectDir, convexDir });
-  if (config === null) return;
-  config.enabled = true;
-  await writeAiConfig({
-    config,
-    projectDir,
-    convexDir,
-    options: { persistEnabledPreference: "always" },
-  });
+  aiFilesConfig,
+}: AiFilesPaths & {
+  aiFilesConfig?: AiFilesProjectConfig | undefined;
+}): Promise<AiFilesProjectConfig> {
+  await installAiFiles({ projectDir, convexDir, aiFilesConfig });
+  // Deleting the deprecated disableStalenessMessage key
+  const { disableStalenessMessage: _, ...rest } = aiFilesConfig ?? {};
+  return { ...rest, enabled: true };
+}
+
+/**
+ * Returns the aiFiles config to write when disabling AI files.
+ */
+export function disableAiFiles(
+  aiFilesConfig?: AiFilesProjectConfig | undefined,
+): AiFilesProjectConfig {
+  // Deleting the deprecated disableStalenessMessage key
+  const { disableStalenessMessage: _, ...rest } = aiFilesConfig ?? {};
+  return { ...rest, enabled: false };
 }
 
 /**
@@ -201,51 +203,31 @@ export async function removeAiFiles({
   projectDir,
   convexDir,
 }: AiFilesPaths): Promise<void> {
-  const config = await readAiConfig({ projectDir, convexDir });
-  if (config === null) {
-    logMessage("No Convex AI files found — nothing to remove.");
-    return;
-  }
+  const result = await attemptReadAiState(convexDir);
+
+  // Skill names are only known when the state file exists and parses.
+  // All other artifacts (AGENTS.md, CLAUDE.md sections, ai dir) can exist
+  // independently, so we always attempt their removal.
+  const installedSkillNames =
+    result.kind === "ok"
+      ? result.state.installedSkillNames
+      : result.kind === "no-file" || result.kind === "parse-error"
+        ? []
+        : exhaustiveCheck(result);
 
   const removals = [
-    await removeAgentsMdSection(projectDir),
-    await removeClaudeMdSection(projectDir),
+    await attemptToRemoveAgentsMdSection(projectDir),
+    await attemptToRemoveClaudeMdSection(projectDir),
     await removeInstalledSkills({
       projectDir,
-      skillNames: config.installedSkillNames,
+      skillNames: installedSkillNames,
     }),
     await removeLegacyCursorRules(projectDir),
     await attemptToDeleteAiDir({ projectDir, convexDir }),
   ];
 
   if (removals.some(Boolean)) logMessage("Convex AI files removed.");
-}
-
-/**
- * Called by `npx convex ai-files disable`.
- *
- * Writes a suppression flag into `convex.json` so `npx convex dev` stops
- * showing AI files install/staleness messages. Files are left in place.
- */
-export async function safelyAttemptToDisableAiFiles(
-  projectDir: string,
-): Promise<void> {
-  try {
-    await writeAiEnabledToProjectConfig({
-      projectDir,
-      enabled: false,
-    });
-    logMessage(
-      `${chalkStderr.green(`✔`)} Convex AI files disabled. Run ${chalkStderr.bold(`npx convex ai-files enable`)} to re-enable.`,
-    );
-  } catch (error) {
-    Sentry.captureException(error);
-    logMessage(
-      chalkStderr.yellow(
-        "Could not write AI message suppression config. Message may reappear.",
-      ),
-    );
-  }
+  else logMessage("No Convex AI files found — nothing to remove.");
 }
 
 async function attemptToDeleteAiDir({
@@ -255,10 +237,11 @@ async function attemptToDeleteAiDir({
   const aiDir = aiDirForConvexDir(convexDir);
   const relPath = path.relative(projectDir, aiDir);
   try {
-    await fs.rm(aiDir, { recursive: true, force: true });
+    await fs.rm(aiDir, { recursive: true });
     logMessage(`${chalkStderr.green("✔")} Deleted ${relPath}/`);
     return true;
   } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
     Sentry.captureException(error);
     logMessage(
       chalkStderr.yellow(`Could not delete ${relPath}/. Remove it manually.`),
@@ -270,27 +253,37 @@ async function attemptToDeleteAiDir({
 async function hasAiFilesBeenInstalledBefore({
   projectDir,
   convexDir,
-}: AiFilesPaths): Promise<boolean> {
+  aiFilesConfig,
+}: AiFilesPaths & {
+  aiFilesConfig?: AiFilesProjectConfig | undefined;
+}): Promise<boolean> {
+  if (isAiFilesDisabled(aiFilesConfig)) return false;
   return (
-    (await hasAiFilesConfig({ projectDir, convexDir })) ||
+    (await hasAiState(convexDir)) ||
     (await hasExistingAiFilesArtifacts({ projectDir, convexDir }))
   );
 }
 
-export async function maybeSetupAiFiles({
+export async function attemptSetupAiFiles({
   ctx,
   convexDir,
   projectDir,
+  aiFilesConfig,
 }: {
   ctx: Context;
+  aiFilesConfig?: AiFilesProjectConfig | undefined;
 } & AiFilesPaths): Promise<void> {
   if (!isInInteractiveTerminal()) return;
+  if (isAiFilesDisabled(aiFilesConfig)) return;
 
-  const config = await readAiConfig({ projectDir, convexDir });
-  if (config !== null && !config.enabled) return;
-
-  if (await hasAiFilesBeenInstalledBefore({ projectDir, convexDir })) {
-    await attemptToInstallAiFiles({ projectDir, convexDir });
+  if (
+    await hasAiFilesBeenInstalledBefore({
+      projectDir,
+      convexDir,
+      aiFilesConfig,
+    })
+  ) {
+    await attemptToInstallAiFiles({ projectDir, convexDir, aiFilesConfig });
     return;
   }
 
@@ -299,5 +292,6 @@ export async function maybeSetupAiFiles({
     default: true,
   });
 
-  if (shouldInstall) await attemptToInstallAiFiles({ projectDir, convexDir });
+  if (shouldInstall)
+    await attemptToInstallAiFiles({ projectDir, convexDir, aiFilesConfig });
 }

package/src/cli/lib/aiFiles/integration.test.ts

@@ -3,8 +3,7 @@ import fs from "fs";
 import os from "os";
 import path from "path";
 import {
-  checkAiFilesStaleness,
-  safelyAttemptToDisableAiFiles,
+  checkAiFilesStalenessAndLog,
   enableAiFiles,
   removeAiFiles,
   installAiFiles,
@@ -46,6 +45,8 @@ vi.mock("child_process", () => ({
   },
 }));
 
+import child_process from "child_process";
+
 // ---------------------------------------------------------------------------
 // Shared helpers
 // ---------------------------------------------------------------------------
@@ -54,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}`);
 }
@@ -92,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 () => {
@@ -148,7 +208,7 @@ describe("ai-files integration with default convex/ directory", () => {
     state.guidelinesHash = "deliberately-stale-hash";
     fs.writeFileSync(statePath(), JSON.stringify(state, null, 2) + "\n");
 
-    await checkAiFilesStaleness({
+    await checkAiFilesStalenessAndLog({
       canonicalGuidelinesHash: "canonical-hash",
       canonicalAgentSkillsSha: null,
       projectDir: tmpDir,
@@ -160,30 +220,9 @@ describe("ai-files integration with default convex/ directory", () => {
     );
   });
 
-  test("staleness check is silent when disabled in convex.json", async () => {
-    await installAiFiles({ projectDir: tmpDir, convexDir });
-    await safelyAttemptToDisableAiFiles(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({
-      canonicalGuidelinesHash: "canonical-hash",
-      canonicalAgentSkillsSha: null,
-      projectDir: 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 installAiFiles({ projectDir: tmpDir, convexDir });
-    await safelyAttemptToDisableAiFiles(tmpDir);
+    patchConvexJson(tmpDir, { aiFiles: { enabled: false } });
 
     expect(readJson(projectConfigPath()).aiFiles.enabled).toBe(false);
     expect(fs.existsSync(guidelinesPath())).toBe(true);
@@ -192,7 +231,7 @@ describe("ai-files integration with default convex/ directory", () => {
   });
 
   test("disable before install writes only convex.json and no AI state file", async () => {
-    await safelyAttemptToDisableAiFiles(tmpDir);
+    patchConvexJson(tmpDir, { aiFiles: { enabled: false } });
 
     expect(readJson(projectConfigPath()).aiFiles.enabled).toBe(false);
     expect(fs.existsSync(statePath())).toBe(false);
@@ -232,7 +271,7 @@ describe("ai-files integration with default convex/ directory", () => {
   test("disable after CLAUDE.md user edits preserves the file", async () => {
     await installAiFiles({ projectDir: tmpDir, convexDir });
     fs.appendFileSync(path.join(tmpDir, "CLAUDE.md"), "My custom note\n");
-    await safelyAttemptToDisableAiFiles(tmpDir);
+    patchConvexJson(tmpDir, { aiFiles: { enabled: false } });
     expect(fs.readFileSync(path.join(tmpDir, "CLAUDE.md"), "utf8")).toContain(
       "My custom note",
     );
@@ -249,23 +288,37 @@ describe("ai-files integration with default convex/ directory", () => {
     );
   });
 
-  test("enable sets enabled flag to true", async () => {
+  test("enable sets enabled flag to true and strips deprecated disableStalenessMessage", async () => {
     await installAiFiles({ projectDir: tmpDir, convexDir });
-    await safelyAttemptToDisableAiFiles(tmpDir);
-    expect(readJson(projectConfigPath()).aiFiles.enabled).toBe(false);
+    patchConvexJson(tmpDir, { aiFiles: { disableStalenessMessage: true } });
+    expect(readJson(projectConfigPath()).aiFiles.disableStalenessMessage).toBe(
+      true,
+    );
 
-    await enableAiFiles({ projectDir: tmpDir, convexDir });
+    const newAiFiles = await enableAiFiles({
+      projectDir: tmpDir,
+      convexDir,
+      aiFilesConfig: readJson(projectConfigPath()).aiFiles,
+    });
+    patchConvexJson(tmpDir, { aiFiles: newAiFiles });
 
-    expect(readJson(projectConfigPath()).aiFiles.enabled).toBe(true);
+    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 installAiFiles({ projectDir: tmpDir, convexDir });
-    await safelyAttemptToDisableAiFiles(tmpDir);
+    patchConvexJson(tmpDir, { aiFiles: { enabled: false } });
     await removeAiFiles({ projectDir: tmpDir, convexDir });
     expect(fs.existsSync(aiDir())).toBe(false);
 
-    await enableAiFiles({ projectDir: 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);
@@ -326,7 +379,7 @@ describe("ai-files integration with default convex/ directory", () => {
   test("checkAiFilesStaleness nags when no state file exists", async () => {
     vi.mocked(logMessage).mockClear();
 
-    await checkAiFilesStaleness({
+    await checkAiFilesStalenessAndLog({
       canonicalGuidelinesHash: null,
       canonicalAgentSkillsSha: null,
       projectDir: tmpDir,
@@ -343,7 +396,7 @@ describe("ai-files integration with default convex/ directory", () => {
     const state = readJson(statePath());
     vi.mocked(logMessage).mockClear();
 
-    await checkAiFilesStaleness({
+    await checkAiFilesStalenessAndLog({
       canonicalGuidelinesHash: state.guidelinesHash,
       canonicalAgentSkillsSha: state.agentSkillsSha,
       projectDir: tmpDir,
@@ -371,10 +424,14 @@ describe("ai-files integration with default convex/ directory", () => {
 
   test("status reports disabled state after disable", async () => {
     await installAiFiles({ projectDir: tmpDir, convexDir });
-    await safelyAttemptToDisableAiFiles(tmpDir);
+    patchConvexJson(tmpDir, { aiFiles: { enabled: false } });
     vi.mocked(logMessage).mockClear();
 
-    await statusAiFiles({ projectDir: tmpDir, convexDir });
+    await statusAiFiles({
+      projectDir: tmpDir,
+      convexDir,
+      aiFilesConfig: readJson(projectConfigPath()).aiFiles,
+    });
 
     expect(vi.mocked(logMessage)).toHaveBeenCalledWith(
       expect.stringContaining("disabled"),
@@ -486,7 +543,7 @@ describe("ai-files integration with functions directory override", () => {
       "utf8",
     );
 
-    await checkAiFilesStaleness({
+    await checkAiFilesStalenessAndLog({
       canonicalGuidelinesHash: "canonical-hash",
       canonicalAgentSkillsSha: null,
       projectDir: tmpDir,
@@ -500,7 +557,7 @@ describe("ai-files integration with functions directory override", () => {
 
   test("disable sets convex.json preference and keeps files", async () => {
     await installAiFiles({ projectDir: tmpDir, convexDir });
-    await safelyAttemptToDisableAiFiles(tmpDir);
+    patchConvexJson(tmpDir, { aiFiles: { enabled: false } });
 
     expect(readJson(projectConfigPath()).aiFiles.enabled).toBe(false);
     expect(fs.existsSync(guidelinesPath())).toBe(true);
@@ -526,7 +583,7 @@ describe("ai-files integration with functions directory override", () => {
       "My custom note\n",
       "utf8",
     );
-    await safelyAttemptToDisableAiFiles(tmpDir);
+    patchConvexJson(tmpDir, { aiFiles: { enabled: false } });
     expect(fs.readFileSync(path.join(tmpDir, "CLAUDE.md"), "utf8")).toContain(
       "My custom note",
     );
@@ -546,8 +603,13 @@ describe("ai-files integration with functions directory override", () => {
 
   test("enable sets enabled flag to true and re-enables status", async () => {
     await installAiFiles({ projectDir: tmpDir, convexDir });
-    await safelyAttemptToDisableAiFiles(tmpDir);
-    await enableAiFiles({ 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.enabled).toBe(true);
@@ -558,14 +620,19 @@ describe("ai-files integration with functions directory override", () => {
 
   test("disable + remove + enable works with overridden functions directory", async () => {
     await installAiFiles({ projectDir: tmpDir, convexDir });
-    await safelyAttemptToDisableAiFiles(tmpDir);
+    patchConvexJson(tmpDir, { aiFiles: { enabled: false } });
     await removeAiFiles({ projectDir: tmpDir, convexDir });
 
     expect(
       fs.existsSync(path.join(tmpDir, "src", "convex", "_generated", "ai")),
     ).toBe(false);
 
-    await enableAiFiles({ projectDir: tmpDir, convexDir });
+    const newAiFiles = await enableAiFiles({
+      projectDir: tmpDir,
+      convexDir,
+      aiFilesConfig: readJson(projectConfigPath()).aiFiles,
+    });
+    patchConvexJson(tmpDir, { aiFiles: newAiFiles });
 
     expect(fs.existsSync(guidelinesPath())).toBe(true);
   });