@ainyc/canonry 4.188.5 → 4.189.0

package/dist/{chunk-3WSOY5VU.js → chunk-HG6NLN7H.js}

@@ -14,7 +14,7 @@ import {
   loadConfig,
   loadConfigRaw,
   saveConfigPatch
-} from "./chunk-RYKQLQPS.js";
+} from "./chunk-YDYB3H4O.js";
 import {
   CC_CACHE_DIR,
   DUCKDB_SPEC,
@@ -120,6 +120,7 @@ import {
   measurementRunCompleteness,
   migrate,
   nextRunFromCron,
+  nextRunFromSchedule,
   notifications,
   parseCookieHeader,
   parseJsonColumn,
@@ -161,7 +162,7 @@ import {
   siteCrawlSnapshots,
   toAlertView,
   usageCounters
-} from "./chunk-AC3ZIRHR.js";
+} from "./chunk-QQLMRABM.js";
 import {
   AGENT_MEMORY_VALUE_MAX_BYTES,
   AGENT_PROVIDER_IDS,
@@ -223,6 +224,7 @@ import {
   bucketOnboardingCount,
   buildRunErrorFromMessages,
   buildSimpleMeasurementDefinition,
+  calendarRecurrenceSchema,
   canonicalizeGtmAccountId,
   canonicalizeGtmContainerId,
   canonicalizeGtmResourceSelection,
@@ -303,7 +305,7 @@ import {
   validationError,
   winnabilityClassLabel,
   withRetry
-} from "./chunk-3HZELBZZ.js";
+} from "./chunk-CDI3YR57.js";
 
 // src/telemetry.ts
 import crypto from "crypto";
@@ -3760,6 +3762,35 @@ function createGeminiEmbedClient(apiKey, baseUrl) {
   };
 }
 
+// ../provider-gemini/src/list-models.ts
+function listModels(config, signal) {
+  return withRetry(async () => {
+    signal.throwIfAborted();
+    const client = createClient2(config);
+    const page = await client.models.list({ config: { pageSize: 100, queryBase: true, abortSignal: signal, httpOptions: { timeout: 2500 } } });
+    const models = [];
+    let seen = 0;
+    for await (const model of page) {
+      signal.throwIfAborted();
+      if (++seen > 1e3) throw new Error("Model catalog exceeded the discovery limit");
+      const id = model.name?.replace(/^(?:publishers\/google\/)?models\//, "");
+      if (!id?.startsWith("gemini-") || /image|tts|audio|live|embedding/.test(id)) continue;
+      if (model.supportedActions && !model.supportedActions.includes("generateContent")) continue;
+      models.push({ id, displayName: model.displayName || id, tier: "standard" });
+    }
+    return models;
+  }, {
+    maxRetries: 1,
+    baseDelayMs: 200,
+    isRetryable: (error) => !signal.aborted && isRetryableHttpError(error),
+    computeDelayMs: (_attempt, error, delay) => {
+      const retryDelay = retryAfterDelayMs(error) ?? delay;
+      if (retryDelay >= 2500) throw error;
+      return retryDelay;
+    }
+  });
+}
+
 // ../provider-gemini/src/adapter.ts
 function toGeminiConfig(config) {
   return {
@@ -3791,6 +3822,7 @@ var geminiAdapter = {
       { id: "gemini-2.0-flash", displayName: "Gemini 2.0 Flash", tier: "standard" }
     ]
   },
+  listModels: (config, signal) => listModels(toGeminiConfig(config), signal),
   validateConfig(config) {
     const result = validateConfig(toGeminiConfig(config));
     return {
@@ -4113,6 +4145,35 @@ function responseToRecord2(response) {
   }
 }
 
+// ../provider-openai/src/list-models.ts
+import OpenAI2 from "openai";
+function listModels2(config, signal) {
+  return withRetry(async () => {
+    signal.throwIfAborted();
+    const client = new OpenAI2({ apiKey: config.apiKey, baseURL: config.baseUrl, maxRetries: 0, timeout: 2500 });
+    const models = [];
+    const page = client.models.list({ signal });
+    let seen = 0;
+    for await (const model of page) {
+      signal.throwIfAborted();
+      if (++seen > 1e3) throw new Error("Model catalog exceeded the discovery limit");
+      if (!/^(?:gpt-|o\d|chat-)/.test(model.id) || /audio|realtime|transcrib|tts|image|codex|search|instruct/.test(model.id)) continue;
+      if (/^gpt-(?:3\.5|4)(?:-|$)/.test(model.id)) continue;
+      models.push({ id: model.id, displayName: model.id, tier: "standard" });
+    }
+    return models;
+  }, {
+    maxRetries: 1,
+    baseDelayMs: 200,
+    isRetryable: (error) => !signal.aborted && isRetryableHttpError(error),
+    computeDelayMs: (_attempt, error, delay) => {
+      const retryDelay = retryAfterDelayMs(error) ?? delay;
+      if (retryDelay >= 2500) throw error;
+      return retryDelay;
+    }
+  });
+}
+
 // ../provider-openai/src/adapter.ts
 function toOpenAIConfig(config) {
   return {
@@ -4143,6 +4204,7 @@ var openaiAdapter = {
       { id: "gpt-4.1", displayName: "GPT-4.1", tier: "standard" }
     ]
   },
+  listModels: listModels2,
   validateConfig(config) {
     const result = validateConfig2(toOpenAIConfig(config));
     return {
@@ -4507,6 +4569,33 @@ function responseToRecord3(response) {
   }
 }
 
+// ../provider-claude/src/list-models.ts
+import Anthropic2 from "@anthropic-ai/sdk";
+function listModels3(config, signal) {
+  return withRetry(async () => {
+    signal.throwIfAborted();
+    const client = new Anthropic2({ apiKey: config.apiKey, baseURL: config.baseUrl, maxRetries: 0, timeout: 2500 });
+    const models = [];
+    const page = client.models.list({ limit: 100 }, { signal });
+    let seen = 0;
+    for await (const model of page) {
+      signal.throwIfAborted();
+      if (++seen > 1e3) throw new Error("Model catalog exceeded the discovery limit");
+      models.push({ id: model.id, displayName: model.display_name, tier: "standard" });
+    }
+    return models;
+  }, {
+    maxRetries: 1,
+    baseDelayMs: 200,
+    isRetryable: (error) => !signal.aborted && isRetryableHttpError(error),
+    computeDelayMs: (_attempt, error, delay) => {
+      const retryDelay = retryAfterDelayMs(error) ?? delay;
+      if (retryDelay >= 2500) throw error;
+      return retryDelay;
+    }
+  });
+}
+
 // ../provider-claude/src/adapter.ts
 function toClaudeConfig(config) {
   return {
@@ -4533,6 +4622,7 @@ var claudeAdapter = {
       { id: "claude-haiku-4-5", displayName: "Claude Haiku 4.5", tier: "fast" }
     ]
   },
+  listModels: listModels3,
   validateConfig(config) {
     const result = validateConfig3(toClaudeConfig(config));
     return {
@@ -4599,7 +4689,7 @@ var claudeAdapter = {
 };
 
 // ../provider-local/src/normalize.ts
-import OpenAI2 from "openai";
+import OpenAI3 from "openai";
 
 // ../provider-local/src/utils.ts
 async function withRetry5(fn, options = {}) {
@@ -4637,7 +4727,7 @@ async function healthcheck4(config) {
   const validation = validateConfig4(config);
   if (!validation.ok) return validation;
   try {
-    const client = new OpenAI2({
+    const client = new OpenAI3({
       baseURL: config.baseUrl,
       apiKey: config.apiKey || "not-needed"
     });
@@ -4667,7 +4757,7 @@ async function healthcheck4(config) {
 }
 async function executeTrackedQuery4(input) {
   const model = input.config.model ?? DEFAULT_MODEL4;
-  const client = new OpenAI2({
+  const client = new OpenAI3({
     baseURL: input.config.baseUrl,
     apiKey: input.config.apiKey || "not-needed"
   });
@@ -4730,7 +4820,7 @@ function extractAnswerText2(rawResponse) {
 }
 async function generateText4(prompt, config) {
   const model = config.model ?? DEFAULT_MODEL4;
-  const client = new OpenAI2({
+  const client = new OpenAI3({
     baseURL: config.baseUrl,
     apiKey: config.apiKey || "not-needed"
   });
@@ -4753,6 +4843,31 @@ function responseToRecord4(response) {
   }
 }
 
+// ../provider-local/src/list-models.ts
+function listModels4(config, signal) {
+  return withRetry(async () => {
+    signal.throwIfAborted();
+    if (!config.baseUrl) throw new Error("Local model discovery requires a configured endpoint");
+    const response = await fetch(`${config.baseUrl.replace(/\/$/, "")}/models`, {
+      method: "GET",
+      signal,
+      headers: config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}
+    });
+    if (!response.ok) throw Object.assign(new Error("Local model discovery failed"), { status: response.status, headers: response.headers });
+    const body = await response.json();
+    return body.data.filter((model) => typeof model.id === "string" && model.id.trim()).slice(0, 1e3).map((model) => ({ id: model.id, displayName: model.id, tier: "standard" }));
+  }, {
+    maxRetries: 1,
+    baseDelayMs: 200,
+    isRetryable: (error) => !signal.aborted && isRetryableHttpError(error),
+    computeDelayMs: (_attempt, error, delay) => {
+      const retryDelay = retryAfterDelayMs(error) ?? delay;
+      if (retryDelay >= 2500) throw error;
+      return retryDelay;
+    }
+  });
+}
+
 // ../provider-local/src/adapter.ts
 function toLocalConfig(config) {
   return {
@@ -4776,6 +4891,7 @@ var localAdapter = {
       { id: "llama3", displayName: "Llama 3", tier: "standard" }
     ]
   },
+  listModels: listModels4,
   validateConfig(config) {
     const result = validateConfig4(toLocalConfig(config));
     return {
@@ -5415,7 +5531,7 @@ var cdpChatgptAdapter = {
 };
 
 // ../provider-perplexity/src/normalize.ts
-import OpenAI3 from "openai";
+import OpenAI4 from "openai";
 
 // ../provider-perplexity/src/utils.ts
 async function withRetry6(fn, options = {}) {
@@ -5454,7 +5570,7 @@ async function healthcheck5(config) {
   const validation = validateConfig5(config);
   if (!validation.ok) return validation;
   try {
-    const client = new OpenAI3({ apiKey: config.apiKey, baseURL: BASE_URL });
+    const client = new OpenAI4({ apiKey: config.apiKey, baseURL: BASE_URL });
     const response = await withRetry6(
       () => client.chat.completions.create({
         model: config.model ?? DEFAULT_MODEL5,
@@ -5479,7 +5595,7 @@ async function healthcheck5(config) {
 }
 async function executeTrackedQuery5(input) {
   const model = input.config.model ?? DEFAULT_MODEL5;
-  const client = new OpenAI3({ apiKey: input.config.apiKey, baseURL: BASE_URL });
+  const client = new OpenAI4({ apiKey: input.config.apiKey, baseURL: BASE_URL });
   const prompt = buildPrompt4(input.query, input.location);
   try {
     const response = await withRetry6(
@@ -5639,7 +5755,7 @@ function extractDomainFromUri4(uri) {
 }
 async function generateText5(prompt, config) {
   const model = config.model ?? DEFAULT_MODEL5;
-  const client = new OpenAI3({ apiKey: config.apiKey, baseURL: BASE_URL });
+  const client = new OpenAI4({ apiKey: config.apiKey, baseURL: BASE_URL });
   const response = await withRetry6(
     () => client.chat.completions.create({
       model,
@@ -11925,7 +12041,7 @@ function readStoredGroundingSources(rawResponse) {
   return result;
 }
 async function backfillInsightsCommand(project, opts) {
-  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-GMG2S55U.js");
+  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-M5TYY4TH.js");
   const config = loadConfig();
   const db = createClient(config.database);
   migrate(db);
@@ -12500,6 +12616,58 @@ var ProviderRegistry = class {
   }
 };
 
+// src/provider-model-catalog.ts
+import { createHash } from "crypto";
+var TTL_MS = 60 * 60 * 1e3;
+var RETRY_MS = 60 * 1e3;
+var TIMEOUT_MS2 = 3e3;
+function createProviderModelCatalog(registry) {
+  const cache = /* @__PURE__ */ new Map();
+  return async (name) => {
+    const provider = registry.get(name);
+    if (!provider) {
+      cache.delete(name);
+      return [];
+    }
+    const fallback = provider.adapter.modelRegistry.knownModels;
+    if (!provider.adapter.listModels) return fallback;
+    const identity = createHash("sha256").update(JSON.stringify(provider.config)).digest("hex");
+    let entry = cache.get(name);
+    if (entry?.identity !== identity) {
+      entry = { identity, expiresAt: 0 };
+      cache.set(name, entry);
+    }
+    if (entry.pending) return entry.pending;
+    if (entry.expiresAt > Date.now()) return entry.models ?? fallback;
+    const current = entry;
+    const controller = new AbortController();
+    let timer;
+    const deadline = new Promise((_resolve, reject) => {
+      timer = setTimeout(() => {
+        controller.abort();
+        reject(new Error("Model discovery timed out"));
+      }, TIMEOUT_MS2);
+    });
+    current.pending = Promise.race([
+      Promise.resolve().then(() => provider.adapter.listModels(provider.config, controller.signal)),
+      deadline
+    ]).then((models) => {
+      const usableModels = [...new Map(models.filter((model) => model.id.trim()).map((model) => [model.id, model])).values()].sort((a, b) => b.id.localeCompare(a.id, "en", { numeric: true }));
+      if (!usableModels.length) throw new Error("Empty model catalog");
+      current.models = usableModels;
+      current.expiresAt = Date.now() + TTL_MS;
+      return current.models;
+    }).catch((error) => {
+      current.expiresAt = Date.now() + Math.max(RETRY_MS, retryAfterDelayMs(error) ?? 0);
+      return current.models ?? fallback;
+    }).finally(() => {
+      clearTimeout(timer);
+      current.pending = void 0;
+    });
+    return current.pending;
+  };
+}
+
 // src/scheduler.ts
 import crypto20 from "crypto";
 import cron from "node-cron";
@@ -12524,6 +12692,10 @@ function ensureDefaultHealthSchedule(db, projectId, now = (/* @__PURE__ */ new D
 function taskKey(projectId, kind) {
   return `${projectId}::${kind}`;
 }
+function scheduleRecurrence(schedule) {
+  if (!schedule.recurrence) return null;
+  return calendarRecurrenceSchema.safeParse(schedule.recurrence).data ?? null;
+}
 var Scheduler = class {
   db;
   callbacks;
@@ -12598,10 +12770,14 @@ var Scheduler = class {
     const allSchedules = this.db.select().from(schedules).where(eq17(schedules.enabled, true)).all();
     for (const schedule of allSchedules) {
       const missedRunAt = schedule.nextRunAt;
-      this.registerCronTask(schedule);
-      if (missedRunAt && new Date(missedRunAt) < /* @__PURE__ */ new Date()) {
-        log14.info("run.catch-up", { projectId: schedule.projectId, kind: schedule.kind, missedRunAt });
-        this.triggerRun(schedule.id, schedule.projectId, schedule.kind);
+      const recurrence = scheduleRecurrence(schedule);
+      const registered = this.registerCronTask(schedule, recurrence ? { preserveNextRunAt: true } : {});
+      if (registered && missedRunAt && new Date(missedRunAt) < /* @__PURE__ */ new Date()) {
+        const answerRecurrence = recurrence && schedule.kind === SchedulableRunKinds["answer-visibility"];
+        if (!recurrence || answerRecurrence || this.claimCalendarOccurrence(schedule, missedRunAt, /* @__PURE__ */ new Date())) {
+          log14.info("run.catch-up", { projectId: schedule.projectId, kind: schedule.kind, missedRunAt });
+          this.triggerRun(schedule.id, schedule.projectId, schedule.kind, answerRecurrence ? missedRunAt : void 0);
+        }
       }
     }
     log14.info("started", { scheduleCount: allSchedules.length });
@@ -12661,12 +12837,21 @@ var Scheduler = class {
       }).where(eq17(schedules.id, scheduleId)).run();
     });
   }
-  registerCronTask(schedule) {
+  registerCronTask(schedule, options = {}) {
+    const recurrence = scheduleRecurrence(schedule);
+    if (recurrence) {
+      this.registerCalendarTask(schedule, recurrence, options);
+      return true;
+    }
+    if (schedule.recurrence) {
+      log14.error("calendar.invalid", { projectId: schedule.projectId, kind: schedule.kind });
+      return false;
+    }
     const { id: scheduleId, projectId, cronExpr, timezone } = schedule;
     const kind = schedule.kind;
     if (!cron.validate(cronExpr)) {
       log14.error("cron.invalid", { projectId, kind, cronExpr });
-      return;
+      return false;
     }
     const task = cron.schedule(cronExpr, () => {
       this.triggerRun(scheduleId, projectId, kind);
@@ -12674,13 +12859,94 @@ var Scheduler = class {
       timezone
     });
     this.tasks.set(taskKey(projectId, kind), task);
-    this.updateScheduleTiming(scheduleId, {
-      nextRunAt: nextRunFromCron(cronExpr, timezone)
-    });
+    if (!options.preserveNextRunAt || !schedule.nextRunAt) {
+      this.updateScheduleTiming(scheduleId, {
+        nextRunAt: nextRunFromCron(cronExpr, timezone)
+      });
+    }
     const label = schedule.preset ?? cronExpr;
     log14.info("cron.registered", { projectId, kind, schedule: label, timezone });
+    return true;
+  }
+  /** Calendar schedules are checked at most once a minute so long intervals
+   * never exceed Node's timeout limit and a delayed event loop cannot fire an
+   * old occurrence twice. The row's nextRunAt is a persistent claim token. */
+  registerCalendarTask(schedule, recurrence, options) {
+    const { id: scheduleId, projectId, timezone } = schedule;
+    const kind = schedule.kind;
+    const key = taskKey(projectId, kind);
+    let timer;
+    let stopped = false;
+    const task = {
+      stop: () => {
+        stopped = true;
+        if (timer) clearTimeout(timer);
+      },
+      destroy: () => {
+        stopped = true;
+        if (timer) clearTimeout(timer);
+      }
+    };
+    const arm = (nextRunAt) => {
+      if (stopped) return;
+      const dueMs = nextRunAt ? Date.parse(nextRunAt) : Number.NaN;
+      const delay = Number.isFinite(dueMs) && dueMs > Date.now() ? Math.min(6e4, Math.max(1, dueMs - Date.now())) : 6e4;
+      timer = setTimeout(tick, delay);
+    };
+    const tick = () => {
+      if (stopped) return;
+      const current = this.db.select().from(schedules).where(eq17(schedules.id, scheduleId)).get();
+      if (!current || !current.enabled || !scheduleRecurrence(current)) {
+        this.remove(projectId, kind);
+        return;
+      }
+      const now = /* @__PURE__ */ new Date();
+      let nextRunAt = current.nextRunAt;
+      if (!nextRunAt || Number.isNaN(Date.parse(nextRunAt))) {
+        nextRunAt = nextRunFromSchedule({ cronExpr: current.cronExpr, timezone: current.timezone, recurrence: scheduleRecurrence(current) }, now);
+        if (nextRunAt) this.updateScheduleTiming(current.id, { nextRunAt });
+      }
+      if (nextRunAt && Date.parse(nextRunAt) <= now.getTime()) {
+        if (kind === SchedulableRunKinds["answer-visibility"]) {
+          this.triggerRun(scheduleId, projectId, kind, nextRunAt);
+        } else if (this.claimCalendarOccurrence(current, nextRunAt, now)) {
+          this.triggerRun(scheduleId, projectId, kind);
+        }
+      }
+      arm(this.db.select({ nextRunAt: schedules.nextRunAt }).from(schedules).where(eq17(schedules.id, scheduleId)).get()?.nextRunAt);
+    };
+    this.tasks.set(key, task);
+    let registeredNextRunAt = schedule.nextRunAt;
+    if (!options.preserveNextRunAt || !registeredNextRunAt) {
+      registeredNextRunAt = nextRunFromSchedule({ cronExpr: schedule.cronExpr, timezone, recurrence }, /* @__PURE__ */ new Date());
+      if (registeredNextRunAt) this.updateScheduleTiming(scheduleId, { nextRunAt: registeredNextRunAt });
+    }
+    if (options.preserveNextRunAt) arm(registeredNextRunAt);
+    else timer = setTimeout(tick, 0);
+    log14.info("calendar.registered", { projectId, kind, recurrence, timezone });
+  }
+  /** Atomically advance a due callback-only calendar occurrence before dispatch. */
+  claimCalendarOccurrence(schedule, dueAt, now) {
+    return this.db.transaction((tx) => {
+      const current = tx.select().from(schedules).where(eq17(schedules.id, schedule.id)).get();
+      if (!current || !current.enabled || current.updatedAt !== schedule.updatedAt || current.nextRunAt !== dueAt) return false;
+      const recurrence = scheduleRecurrence(current);
+      if (!recurrence) return false;
+      const nextRunAt = nextRunFromSchedule({ cronExpr: current.cronExpr, timezone: current.timezone, recurrence }, now);
+      if (!nextRunAt) return false;
+      const result = tx.update(schedules).set({
+        nextRunAt,
+        updatedAt: nextScheduleUpdatedAt(current.updatedAt)
+      }).where(and15(
+        eq17(schedules.id, current.id),
+        eq17(schedules.enabled, true),
+        eq17(schedules.nextRunAt, dueAt),
+        eq17(schedules.updatedAt, schedule.updatedAt)
+      )).run();
+      return result.changes === 1;
+    });
   }
-  triggerRun(scheduleId, projectId, kind) {
+  triggerRun(scheduleId, projectId, kind, claimedOccurrence) {
     try {
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const currentSchedule = this.db.select().from(schedules).where(eq17(schedules.id, scheduleId)).get();
@@ -12689,7 +12955,16 @@ var Scheduler = class {
         this.remove(projectId, kind);
         return;
       }
-      const nextRunAt = nextRunFromCron(currentSchedule.cronExpr, currentSchedule.timezone);
+      const recurrence = scheduleRecurrence(currentSchedule);
+      if (claimedOccurrence && (!recurrence || currentSchedule.nextRunAt !== claimedOccurrence)) {
+        log14.info("calendar.stale-claim", { projectId, scheduleId, kind });
+        return;
+      }
+      const nextRunAt = nextRunFromSchedule({
+        cronExpr: currentSchedule.cronExpr,
+        timezone: currentSchedule.timezone,
+        recurrence
+      });
       const project = this.db.select().from(projects).where(eq17(projects.id, projectId)).get();
       if (!project) {
         log14.error("project.not-found", { projectId, kind, msg: "skipping scheduled run" });
@@ -12862,6 +13137,10 @@ var Scheduler = class {
       const locationLabel = resolvedLocation?.label ?? null;
       const scheduleProviders = currentSchedule.providers;
       const providers = scheduleProviders.length > 0 ? scheduleProviders : void 0;
+      if (claimedOccurrence && recurrence && !nextRunAt) {
+        log14.error("calendar.invalid", { projectId, kind, scheduleId });
+        return;
+      }
       const queueResult = queueRunIfProjectIdle(this.db, {
         createdAt: now,
         kind: "answer-visibility",
@@ -12870,17 +13149,29 @@ var Scheduler = class {
         location: locationLabel,
         providers,
         runnableProviders: this.callbacks.getRunnableProviderNames?.(),
-        providerModels: this.callbacks.getEffectiveProviderModels?.()
+        providerModels: this.callbacks.getEffectiveProviderModels?.(),
+        ...claimedOccurrence && recurrence && currentSchedule.nextRunAt === claimedOccurrence ? {
+          scheduleClaim: {
+            scheduleId: currentSchedule.id,
+            dueAt: claimedOccurrence,
+            expectedUpdatedAt: currentSchedule.updatedAt,
+            nextRunAt
+          }
+        } : {}
       });
       if (queueResult.conflict) {
+        if (queueResult.scheduleClaimed === false) {
+          log14.info("calendar.skipped-claimed", { projectName: project.name, scheduleId: currentSchedule.id });
+          return;
+        }
         log14.info("run.skipped-active", { projectName: project.name, activeRunId: queueResult.activeRunId });
-        this.updateScheduleTiming(currentSchedule.id, {
-          nextRunAt
-        });
+        if (!claimedOccurrence) this.updateScheduleTiming(currentSchedule.id, { nextRunAt });
         return;
       }
       const runId = queueResult.runId;
-      this.updateScheduleTiming(currentSchedule.id, {
+      this.updateScheduleTiming(currentSchedule.id, claimedOccurrence ? {
+        lastRunAt: now
+      } : {
         lastRunAt: now,
         nextRunAt
       });
@@ -15440,6 +15731,12 @@ function mcpTransportPaths() {
   }
   return paths;
 }
+function mcpHttpHealth(app, apiPrefix) {
+  const available = mcpTransportPaths().every(
+    (path9) => ["POST", "GET", "DELETE"].every((method) => app.hasRoute({ method, url: `${apiPrefix}${path9}` }))
+  );
+  return { status: available ? "available" : "unavailable" };
+}
 function registerMcpHttpRoutes(scope, opts) {
   const sessions = /* @__PURE__ */ new Map();
   const now = opts.now ?? (() => Date.now());
@@ -18677,6 +18974,7 @@ async function createServer(opts) {
       includeCanonryLocal: true
     },
     providerSummary,
+    getProviderModels: createProviderModelCatalog(registry),
     providerAdapters: [...API_ADAPTERS, ...BROWSER_ADAPTERS].map((a) => ({
       name: a.name,
       displayName: a.displayName,
@@ -19099,6 +19397,7 @@ async function createServer(opts) {
       status: "ok",
       service: "canonry",
       version: PKG_VERSION2,
+      mcp: mcpHttpHealth(app, apiPrefix),
       ...basePath ? { basePath: basePath.replace(/\/$/, "") } : {},
       ...update ? { updateAvailable: update } : {}
     };

package/dist/{chunk-YI7PHVUQ.js → chunk-J533DKYE.js}

@@ -5,11 +5,11 @@ import {
   installSkills,
   loadConfigRaw,
   saveConfigPatch
-} from "./chunk-RYKQLQPS.js";
+} from "./chunk-YDYB3H4O.js";
 import {
   SKILL_MANIFEST_FILENAME,
   SkillsClients
-} from "./chunk-3HZELBZZ.js";
+} from "./chunk-CDI3YR57.js";
 
 // src/skills-autosync.ts
 import fs from "fs";