convex 1.34.1 → 1.35.1

package/src/cli/lib/expiration.ts

@@ -0,0 +1,124 @@
+type ParsedExpirationSuccess =
+  | { kind: "none" }
+  | { kind: "absolute"; timestampMs: number }
+  | { kind: "relative"; amount: number; unit: "minute" | "hour" | "day" };
+
+type ParsedExpiration =
+  | ParsedExpirationSuccess
+  | { kind: "error"; message: string };
+
+const PARSE_ERROR_MESSAGE =
+  `Supported formats:\n` +
+  `  "none"                          — no expiration\n` +
+  `  "in 7 days"                     — relative (minutes, hours, days)\n` +
+  `  "2026-04-01T00:00:00Z"          — UTC datetime\n` +
+  `  "1711828382"                    — Unix timestamp (seconds)\n` +
+  `  "1711828382000"                 — Unix timestamp (milliseconds)`;
+
+const UNIT_MS = {
+  minute: 60 * 1000,
+  hour: 60 * 60 * 1000,
+  day: 24 * 60 * 60 * 1000,
+} as const;
+
+/**
+ * Parse an expiration input string into a structured representation.
+ * Does not depend on the current time.
+ */
+export function parseExpiration(input: string): ParsedExpiration {
+  const trimmed = input.trim();
+
+  if (trimmed.toLowerCase() === "none") {
+    return { kind: "none" };
+  }
+
+  // All digits → Unix timestamp
+  if (/^\d+$/.test(trimmed)) {
+    const n = Number(trimmed);
+
+    return {
+      kind: "absolute",
+      timestampMs:
+        n < 1e12 // 1e12 milliseconds is a date in 2001 → unambiguous
+          ? n * 1000 // seconds → convert to ms
+          : n, // already milliseconds
+    };
+  }
+
+  // UTC datetime: "2026-04-01T00:00:00Z"
+  if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/.test(trimmed)) {
+    const date = new Date(trimmed);
+    if (isNaN(date.getTime())) {
+      return {
+        kind: "error",
+        message: `Invalid UTC datetime: "${trimmed}". ${PARSE_ERROR_MESSAGE}`,
+      };
+    }
+    return { kind: "absolute", timestampMs: date.getTime() };
+  }
+
+  // Relative: "in 3 hours", "in 1 day", "in 45 minutes"
+  const relativeMatch = trimmed.match(/^in\s+(\d+)\s+(minute|hour|day)s?$/i);
+  if (relativeMatch) {
+    const amount = Number(relativeMatch[1]);
+    const unit = relativeMatch[2].toLowerCase() as "minute" | "hour" | "day";
+    return { kind: "relative", amount, unit };
+  }
+
+  return {
+    kind: "error",
+    message: `Invalid expiration format: "${trimmed}". ${PARSE_ERROR_MESSAGE}`,
+  };
+}
+
+/**
+ * Resolve a parsed expiration into a timestamp in milliseconds, or null for "none".
+ */
+export function resolveExpiration(
+  parsed: ParsedExpirationSuccess,
+  now?: number,
+): number | null {
+  switch (parsed.kind) {
+    case "none":
+      return null;
+    case "absolute":
+      return parsed.timestampMs;
+    case "relative": {
+      const base = now ?? Date.now();
+      return base + parsed.amount * UNIT_MS[parsed.unit];
+    }
+  }
+}
+
+type ValidationResult =
+  | { kind: "success" }
+  | { kind: "error"; message: string };
+
+/**
+ * Validate that a resolved expiration timestamp is acceptable.
+ */
+export function validateExpiration(
+  timestampMs: number,
+  now?: number,
+): ValidationResult {
+  const base = now ?? Date.now();
+  const thirtyMinutes = 30 * 60 * 1000;
+  const oneYear = 365 * 24 * 60 * 60 * 1000;
+
+  if (timestampMs <= base) {
+    return { kind: "error", message: "Expiration must be in the future." };
+  }
+  if (timestampMs - base < thirtyMinutes) {
+    return {
+      kind: "error",
+      message: "Expiration must be at least 30 minutes from now.",
+    };
+  }
+  if (timestampMs - base > oneYear) {
+    return {
+      kind: "error",
+      message: "Expiration must be at most 1 year from now.",
+    };
+  }
+  return { kind: "success" };
+}

package/src/cli/lib/generatedFunctionLogsApi.ts

@@ -33,6 +33,8 @@ export interface components {
             timestamp: number;
             udfType: components["schemas"]["UdfTypeJson"];
             usageStats: components["schemas"]["UsageStatsJson"];
+            /** Format: double */
+            userExecutionTime?: number | null;
         } | {
             componentPath?: string | null;
             executionId: string;
@@ -58,9 +60,10 @@ export interface components {
             udfPath?: string | null;
         };
         OccInfoJson: {
+            componentPath?: string | null;
             documentId?: string | null;
             /** Format: int64 */
-            retryCount: number;
+            retryCount?: number | null;
             tableName?: string | null;
             writeSource?: string | null;
         };
@@ -86,6 +89,10 @@ export interface components {
         /** @enum {string} */
         UdfTypeJson: "Query" | "Mutation" | "Action" | "HttpAction";
         UsageStatsJson: {
+            /** Format: int64 */
+            databaseIoReadBytes: number;
+            /** Format: int64 */
+            databaseIoWriteBytes: number;
             /** Format: int64 */
             databaseReadBytes: number;
             /** Format: int64 */
@@ -99,9 +106,17 @@ export interface components {
             /** Format: int64 */
             storageWriteBytes: number;
             /** Format: int64 */
+            textIndexQueryBytes: number;
+            /** Format: int64 */
+            textIndexWriteQueryBytes: number;
+            /** Format: int64 */
             vectorIndexReadBytes: number;
             /** Format: int64 */
+            vectorIndexReadQueryBytes: number;
+            /** Format: int64 */
             vectorIndexWriteBytes: number;
+            /** Format: int64 */
+            vectorIndexWriteQueryBytes: number;
         };
         Value: unknown;
     };

package/src/cli/lib/init.ts

@@ -26,6 +26,9 @@ export async function finalizeConfiguration(
     (envFileConfig.convexUrlEnvVar || envFileConfig.siteUrlEnvVar);
 
   if (isEnvFileConfigChanged) {
+    const deploymentEnvVarMessage = options.changedDeploymentEnvVar
+      ? `    name as CONVEX_DEPLOYMENT\n`
+      : "";
     const urlUpdateMessages = [];
     if (envFileConfig.convexUrlEnvVar) {
       urlUpdateMessages.push(
@@ -39,7 +42,7 @@ export async function finalizeConfiguration(
     }
     logFinishedStep(
       `${messageForDeploymentType(options.deploymentType, options.url)} and saved its:\n` +
-        `    name as CONVEX_DEPLOYMENT\n` +
+        deploymentEnvVarMessage +
         urlUpdateMessages.join("") +
         ` to ${envFileConfig.envFile}`,
     );
@@ -53,7 +56,8 @@ export async function finalizeConfiguration(
   }
   if (
     options.deploymentType === "anonymous" &&
-    process.env.CONVEX_AGENT_MODE !== "anonymous"
+    process.env.CONVEX_AGENT_MODE !== "anonymous" &&
+    ctx.bigBrainAuth() === null
   ) {
     logMessage(
       `Run \`npx convex login\` at any time to create an account and link this deployment.`,

package/src/cli/lib/insights.ts

@@ -163,7 +163,7 @@ export async function fetchRawInsightsData(
     from: fromDate,
     to: toDate,
   });
-  const bbFetch = await bigBrainFetch(ctx);
+  const bbFetch = bigBrainFetch(ctx);
   const res = await bbFetch(
     new URL(
       `dashboard/teams/${teamId}/usage/query?${queryParams.toString()}`,

package/src/cli/lib/localDeployment/anonymous.ts

@@ -35,7 +35,7 @@ import { handlePotentialUpgrade } from "./upgrade.js";
 import {
   isOffline,
   generateInstanceSecret,
-  choosePorts,
+  chooseLocalBackendPorts,
   LOCAL_BACKEND_INSTANCE_SECRET,
 } from "./utils.js";
 import { handleDashboard } from "./dashboard.js";
@@ -48,7 +48,7 @@ import { nodeFs } from "../../../bundler/fs.js";
 import { doInitConvexFolder } from "../codegen.js";
 import { readProjectConfig } from "../config.js";
 import { functionsDir } from "../utils/utils.js";
-import { maybeSetupAiFiles } from "../aiFiles/index.js";
+import { attemptSetupAiFiles } from "../aiFiles/index.js";
 
 export async function handleAnonymousDeployment(
   ctx: Context,
@@ -80,7 +80,8 @@ export async function handleAnonymousDeployment(
   });
   if (
     deployment.kind === "first" &&
-    process.env.CONVEX_AGENT_MODE !== "anonymous"
+    process.env.CONVEX_AGENT_MODE !== "anonymous" &&
+    process.stdin.isTTY
   ) {
     logMessage(
       "This command, `npx convex dev`, will run your Convex backend locally and update it with the function you write in the `convex/` directory.",
@@ -146,11 +147,10 @@ export async function handleAnonymousDeployment(
     adminKey = data.adminKey;
   }
 
-  const [cloudPort, sitePort] = await choosePorts(ctx, {
-    count: 2,
-    startPort: 3210,
-    requestedPorts: [options.ports?.cloud ?? null, options.ports?.site ?? null],
-  });
+  const { cloudPort, sitePort } = await chooseLocalBackendPorts(
+    ctx,
+    options.ports,
+  );
   const onActivity = async (isOffline: boolean, _wasOffline: boolean) => {
     await ensureBackendRunning(ctx, {
       cloudPort,
@@ -187,7 +187,12 @@ export async function handleAnonymousDeployment(
     const { configPath, projectConfig } = await readProjectConfig(ctx);
     const convexDir = path.resolve(functionsDir(configPath, projectConfig));
     const projectDir = path.resolve(path.dirname(configPath));
-    await maybeSetupAiFiles({ ctx, convexDir, projectDir });
+    await attemptSetupAiFiles({
+      ctx,
+      aiFilesConfig: projectConfig.aiFiles,
+      convexDir,
+      projectDir,
+    });
   }
   return {
     adminKey,
@@ -354,6 +359,11 @@ async function chooseDeployment(
     return { deploymentName: generateDeploymentName(), kind: "new" };
   }
 
+  // Non-interactive terminal - auto-create a new deployment
+  if (!process.stdin.isTTY) {
+    return { deploymentName: generateDeploymentName(), kind: "new" };
+  }
+
   // Legacy deployments exist - prompt user to choose
   const newOrExisting = await promptSearch(ctx, {
     message: "Which project would you like to use?",

package/src/cli/lib/localDeployment/localDeployment.ts

@@ -25,7 +25,7 @@ import { OnDeploymentActivityFunc } from "../deployment.js";
 import { promptSearch } from "../utils/prompts.js";
 import { LocalDeploymentError, printLocalDeploymentOnError } from "./errors.js";
 import {
-  choosePorts,
+  chooseLocalBackendPorts,
   printLocalDeploymentWelcomeMessage,
   isOffline,
   LOCAL_BACKEND_INSTANCE_SECRET,
@@ -93,11 +93,10 @@ export async function handleLocalDeployment(
         }
       : { kind: "version", version: options.backendVersion },
   );
-  const [cloudPort, sitePort] = await choosePorts(ctx, {
-    count: 2,
-    startPort: 3210,
-    requestedPorts: [options.ports?.cloud ?? null, options.ports?.site ?? null],
-  });
+  const { cloudPort, sitePort } = await chooseLocalBackendPorts(
+    ctx,
+    options.ports,
+  );
   const { deploymentName, adminKey } = await bigBrainStart(ctx, {
     port: cloudPort,
     projectSlug: options.projectSlug,
@@ -207,11 +206,10 @@ async function handleOffline(
     kind: "version",
     version: config.backendVersion,
   });
-  const [cloudPort, sitePort] = await choosePorts(ctx, {
-    count: 2,
-    startPort: 3210,
-    requestedPorts: [options.ports?.cloud ?? null, options.ports?.site ?? null],
-  });
+  const { cloudPort, sitePort } = await chooseLocalBackendPorts(
+    ctx,
+    options.ports,
+  );
   saveDeploymentConfig(ctx, "local", deploymentName, config);
   await runLocalBackend(ctx, {
     binaryPath,

package/src/cli/lib/localDeployment/run.ts

@@ -295,7 +295,7 @@ type LocalBackendStatus =
   | { kind: "different"; name: string }
   | { kind: "not-running" };
 
-async function fetchLocalBackendStatus(args: {
+export async function fetchLocalBackendStatus(args: {
   url: string;
   deploymentName: string;
 }): Promise<LocalBackendStatus> {

package/src/cli/lib/localDeployment/upgrade.ts

@@ -76,6 +76,7 @@ export async function handlePotentialUpgrade(
   );
   const confirmed =
     args.forceUpgrade ||
+    !process.stdin.isTTY ||
     (await promptYesNo(ctx, {
       message: `This deployment is using an older version of the Convex backend. Upgrade now?`,
       default: true,
@@ -102,16 +103,17 @@ export async function handlePotentialUpgrade(
       isLatestVersion: false,
     });
   }
-  const choice = args.forceUpgrade
-    ? "transfer"
-    : await promptOptions(ctx, {
-        message: "Transfer data from existing deployment?",
-        default: "transfer",
-        choices: [
-          { name: "transfer data", value: "transfer" },
-          { name: "start fresh", value: "reset" },
-        ],
-      });
+  const choice =
+    args.forceUpgrade || !process.stdin.isTTY
+      ? "transfer"
+      : await promptOptions(ctx, {
+          message: "Transfer data from existing deployment?",
+          default: "transfer",
+          choices: [
+            { name: "transfer data", value: "transfer" },
+            { name: "start fresh", value: "reset" },
+          ],
+        });
   const deploymentStatePath = deploymentStateDir(
     ctx,
     args.deploymentKind,

package/src/cli/lib/localDeployment/utils.ts

@@ -39,6 +39,18 @@ export async function choosePorts(
   return ports;
 }
 
+export async function chooseLocalBackendPorts(
+  ctx: Context,
+  ports?: { cloud?: number | null; site?: number | null },
+): Promise<{ cloudPort: number; sitePort: number }> {
+  const [cloudPort, sitePort] = await choosePorts(ctx, {
+    count: 2,
+    startPort: 3210,
+    requestedPorts: [ports?.cloud ?? null, ports?.site ?? null],
+  });
+  return { cloudPort, sitePort };
+}
+
 export async function isOffline(): Promise<boolean> {
   // TODO(ENG-7080) -- implement this for real
   return false;

package/src/cli/lib/mcp/tools/status.ts

@@ -97,7 +97,7 @@ export const StatusTool: ConvexTool<typeof inputSchema, typeof outputSchema> = {
     ];
     // Also get the prod cloud deployment if we're using a cloud-hosted dev-deployment
     if (
-      selectionWithinProject.kind === "ownDev" &&
+      selectionWithinProject.kind === "unspecified" &&
       !(
         deploymentSelection.kind === "existingDeployment" &&
         deploymentSelection.deploymentToActOn.deploymentFields === null

package/src/cli/lib/updates.test.ts

@@ -1,8 +1,8 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { checkVersion } from "./updates.js";
+import { checkVersionAndAiFilesStaleness } from "./updates.js";
 import { getVersion } from "./versionApi.js";
 import { logMessage } from "../../bundler/log.js";
-import { checkAiFilesStaleness } from "./aiFiles/index.js";
+import { checkAiFilesStalenessAndLog } from "./aiFiles/index.js";
 import { readProjectConfig } from "./config.js";
 import type { Context } from "../../bundler/context.js";
 
@@ -11,7 +11,12 @@ vi.mock("./versionApi.js", () => ({
 }));
 
 vi.mock("./aiFiles/index.js", () => ({
-  checkAiFilesStaleness: vi.fn(),
+  checkAiFilesStalenessAndLog: vi.fn(),
+  isAiFilesDisabled: vi.fn((aiFilesConfig) =>
+    aiFilesConfig?.enabled !== undefined
+      ? aiFilesConfig.enabled === false
+      : aiFilesConfig?.disableStalenessMessage === true,
+  ),
 }));
 
 vi.mock("../../bundler/log.js", () => ({
@@ -24,15 +29,26 @@ vi.mock("./config.js", () => ({
 
 const mockGetVersion = vi.mocked(getVersion);
 const mockLogMessage = vi.mocked(logMessage);
-const mockCheckAiFilesStaleness = vi.mocked(checkAiFilesStaleness);
+const mockCheckAiFilesStalenessAndLog = vi.mocked(checkAiFilesStalenessAndLog);
 const mockReadProjectConfig = vi.mocked(readProjectConfig);
 
 const fakeCtx = {} as Context;
 
-describe("updates", () => {
+const okVersion = (overrides?: object) => ({
+  kind: "ok" as const,
+  data: {
+    message: null,
+    guidelinesHash: "abc-guidelines-hash",
+    agentSkillsSha: "abc-skills-sha",
+    disableSkillsCli: false,
+    ...overrides,
+  },
+});
+
+describe("checkVersionAndAiFilesStaleness", () => {
   beforeEach(() => {
     vi.clearAllMocks();
-    mockCheckAiFilesStaleness.mockResolvedValue(undefined);
+    mockCheckAiFilesStalenessAndLog.mockResolvedValue(undefined);
     mockReadProjectConfig.mockResolvedValue({
       projectConfig: {
         functions: "convex",
@@ -48,82 +64,93 @@ describe("updates", () => {
     vi.resetAllMocks();
   });
 
-  describe("checkVersion", () => {
-    it("logs message and passes both hashes to staleness check", async () => {
-      const sha = "abc123def456abc123def456abc123def456abc1";
-      mockGetVersion.mockResolvedValue({
-        kind: "ok",
-        data: {
-          message: "New version available: 1.2.3",
-          guidelinesHash:
-            "02e43fc1ff0ee48db8da468f5c7525877d8056fcd56c77d78a166ac447efb91c",
-          agentSkillsSha: sha,
-          disableSkillsCli: false,
-        },
-      });
-
-      await checkVersion(fakeCtx);
-
-      expect(mockGetVersion).toHaveBeenCalled();
-      expect(mockLogMessage).toHaveBeenCalledWith(
-        "New version available: 1.2.3",
-      );
-      expect(mockCheckAiFilesStaleness).toHaveBeenCalledWith({
-        canonicalGuidelinesHash:
-          "02e43fc1ff0ee48db8da468f5c7525877d8056fcd56c77d78a166ac447efb91c",
-        canonicalAgentSkillsSha: sha,
-        projectDir: expect.any(String),
-        convexDir: expect.any(String),
-      });
-    });
+  it("logs version message when server provides one", async () => {
+    mockGetVersion.mockResolvedValue(
+      okVersion({ message: "New version available: 1.2.3" }),
+    );
+
+    await checkVersionAndAiFilesStaleness(fakeCtx);
+
+    expect(mockLogMessage).toHaveBeenCalledWith("New version available: 1.2.3");
+  });
+
+  it("does not log when version has no message", async () => {
+    mockGetVersion.mockResolvedValue(okVersion());
 
-    it("does not log when version has no message", async () => {
-      mockGetVersion.mockResolvedValue({
-        kind: "ok",
-        data: {
-          message: null,
-          guidelinesHash:
-            "02e43fc1ff0ee48db8da468f5c7525877d8056fcd56c77d78a166ac447efb91c",
-          agentSkillsSha: null,
-          disableSkillsCli: false,
-        },
-      });
-
-      await checkVersion(fakeCtx);
-
-      expect(mockGetVersion).toHaveBeenCalled();
-      expect(mockLogMessage).not.toHaveBeenCalled();
+    await checkVersionAndAiFilesStaleness(fakeCtx);
+
+    expect(mockLogMessage).not.toHaveBeenCalled();
+  });
+
+  it("does nothing when getVersion returns error", async () => {
+    mockGetVersion.mockResolvedValue({ kind: "error" });
+
+    await checkVersionAndAiFilesStaleness(fakeCtx);
+
+    expect(mockLogMessage).not.toHaveBeenCalled();
+    expect(mockCheckAiFilesStalenessAndLog).not.toHaveBeenCalled();
+  });
+
+  it("passes hashes and project paths to staleness check", async () => {
+    mockGetVersion.mockResolvedValue(
+      okVersion({
+        guidelinesHash:
+          "02e43fc1ff0ee48db8da468f5c7525877d8056fcd56c77d78a166ac447efb91c",
+        agentSkillsSha: "abc123def456abc123def456abc123def456abc1",
+      }),
+    );
+
+    await checkVersionAndAiFilesStaleness(fakeCtx);
+
+    expect(mockCheckAiFilesStalenessAndLog).toHaveBeenCalledWith({
+      canonicalGuidelinesHash:
+        "02e43fc1ff0ee48db8da468f5c7525877d8056fcd56c77d78a166ac447efb91c",
+      canonicalAgentSkillsSha: "abc123def456abc123def456abc123def456abc1",
+      projectDir: expect.any(String),
+      convexDir: expect.any(String),
     });
+  });
 
-    it("doesn't do anything when getVersion returns error", async () => {
-      mockGetVersion.mockResolvedValue({ kind: "error" });
+  it("passes null hashes when version has none", async () => {
+    mockGetVersion.mockResolvedValue(
+      okVersion({ guidelinesHash: null, agentSkillsSha: null }),
+    );
 
-      await checkVersion(fakeCtx);
+    await checkVersionAndAiFilesStaleness(fakeCtx);
 
-      expect(mockGetVersion).toHaveBeenCalled();
-      expect(mockLogMessage).not.toHaveBeenCalled();
-      expect(mockCheckAiFilesStaleness).not.toHaveBeenCalled();
+    expect(mockCheckAiFilesStalenessAndLog).toHaveBeenCalledWith({
+      canonicalGuidelinesHash: null,
+      canonicalAgentSkillsSha: null,
+      projectDir: expect.any(String),
+      convexDir: expect.any(String),
     });
+  });
 
-    it("passes null hashes to staleness check when version has none", async () => {
-      mockGetVersion.mockResolvedValue({
-        kind: "ok",
-        data: {
-          message: "New version available: 1.2.3",
-          guidelinesHash: null,
-          agentSkillsSha: null,
-          disableSkillsCli: false,
-        },
-      });
-
-      await checkVersion(fakeCtx);
-
-      expect(mockCheckAiFilesStaleness).toHaveBeenCalledWith({
-        canonicalGuidelinesHash: null,
-        canonicalAgentSkillsSha: null,
-        projectDir: expect.any(String),
-        convexDir: expect.any(String),
-      });
+  it("skips staleness check when aiFiles.disableStalenessMessage is true", async () => {
+    mockGetVersion.mockResolvedValue(okVersion());
+    mockReadProjectConfig.mockResolvedValue({
+      projectConfig: {
+        functions: "convex",
+        node: { externalPackages: [] },
+        generateCommonJSApi: false,
+        codegen: { staticApi: true, staticDataModel: true },
+        aiFiles: { disableStalenessMessage: true },
+      },
+      configPath: "convex.json",
     });
+
+    await checkVersionAndAiFilesStaleness(fakeCtx);
+
+    expect(mockCheckAiFilesStalenessAndLog).not.toHaveBeenCalled();
+  });
+
+  it("silently skips staleness check when project config cannot be resolved", async () => {
+    mockGetVersion.mockResolvedValue(okVersion());
+    mockReadProjectConfig.mockRejectedValue(new Error("no convex.json"));
+
+    await expect(
+      checkVersionAndAiFilesStaleness(fakeCtx),
+    ).resolves.toBeUndefined();
+    expect(mockCheckAiFilesStalenessAndLog).not.toHaveBeenCalled();
   });
 });

package/src/cli/lib/updates.ts

@@ -3,31 +3,33 @@ import { logMessage } from "../../bundler/log.js";
 import type { Context } from "../../bundler/context.js";
 import { readProjectConfig } from "./config.js";
 import { functionsDir } from "./utils/utils.js";
-import { checkAiFilesStaleness } from "./aiFiles/index.js";
+import {
+  checkAiFilesStalenessAndLog,
+  isAiFilesDisabled,
+} from "./aiFiles/index.js";
 import { getVersion } from "./versionApi.js";
 
 /**
- * Check the version of the `convex` NPM package and nag if Convex AI files
- * are out of date.
+ * Fetch the latest version data, log any server nag message, and warn if
+ * Convex AI files are out of date. Both checks share the one getVersion()
+ * round-trip.
  */
-export async function checkVersion(ctx: Context) {
+export async function checkVersionAndAiFilesStaleness(ctx: Context) {
   const version = await getVersion();
+  if (version.kind === "error") return;
 
-  if (version.kind === "error") {
-    return;
-  }
-
-  if (version.data.message) {
-    logMessage(version.data.message);
-  }
+  if (version.data.message) logMessage(version.data.message);
 
   try {
     const { configPath, projectConfig } = await readProjectConfig(ctx);
+    const aiFilesConfig = projectConfig.aiFiles;
+    if (isAiFilesDisabled(aiFilesConfig)) return;
     const convexDir = path.resolve(functionsDir(configPath, projectConfig));
     const projectDir = path.resolve(path.dirname(configPath));
-    await checkAiFilesStaleness({
+    await checkAiFilesStalenessAndLog({
       canonicalGuidelinesHash: version.data.guidelinesHash,
       canonicalAgentSkillsSha: version.data.agentSkillsSha,
+      aiFilesConfig,
       projectDir,
       convexDir,
     });