@cleocode/core 2026.9.26 → 2026.10.1

package/dist/llm/plugin-facade.js

@@ -17463,6 +17463,210 @@ var init_nexus_account = __esm({
   }
 });
 
+// packages/contracts/src/nexus-cloud.ts
+import { z as z26 } from "zod";
+var NEXUS_DEVICE_STATES, NEXUS_CLOUD_PROFILES, NEXUS_DEVICE_STATE_UNKNOWN, isoTime, profile, deviceState, nexusCloudCredentialSchema, nexusCloudDeviceSchema, nexusCloudOrganizationSchema, nexusCloudUserSchema, nexusCloudWhoamiSchema, nexusCloudDevicePageSchema, nexusCloudPresenceSchema, nexusCloudReplicaSchema, nexusCloudDeviceCountsSchema, projectFields, nexusCloudProjectListItemSchema, nexusCloudProjectPageSchema, nexusCloudProjectDetailSchema, nexusCloudReplicaPageSchema, NEXUS_STATUS_CHECK_IDS, NEXUS_STATUS_VERDICTS, CLOUD_STATUS_VERDICTS, knownCheckId, nexusCloudStatusCheckSchema, nexusCloudStatusSchema;
+var init_nexus_cloud = __esm({
+  "packages/contracts/src/nexus-cloud.ts"() {
+    "use strict";
+    NEXUS_DEVICE_STATES = ["active", "signed-out", "revoked"];
+    NEXUS_CLOUD_PROFILES = ["device", "read-only"];
+    NEXUS_DEVICE_STATE_UNKNOWN = "unknown";
+    isoTime = z26.iso.datetime({ offset: true });
+    profile = z26.enum(NEXUS_CLOUD_PROFILES).nullable().catch(null);
+    deviceState = z26.enum([...NEXUS_DEVICE_STATES, NEXUS_DEVICE_STATE_UNKNOWN]).catch(NEXUS_DEVICE_STATE_UNKNOWN);
+    nexusCloudCredentialSchema = z26.object({
+      kind: z26.enum(["device", "session"]),
+      credentialId: z26.string().nullable().optional(),
+      profile: profile.optional(),
+      scopes: z26.array(z26.string()).default([]),
+      createdAt: isoTime.nullable().optional(),
+      lastUsedAt: isoTime.nullable().optional(),
+      /** When the credential expires if it is not used again; null for sessions. */
+      idleExpiresAt: isoTime.nullable().optional()
+    });
+    nexusCloudDeviceSchema = z26.object({
+      deviceId: z26.string(),
+      name: z26.string(),
+      platform: z26.string().optional(),
+      arch: z26.string().nullable().optional(),
+      cliVersion: z26.string().nullable().optional(),
+      createdAt: isoTime.optional(),
+      lastSeenAt: isoTime.nullable().optional(),
+      state: deviceState,
+      signedOutAt: isoTime.nullable().optional(),
+      /** Base64 device certificate; null until the device holds a key grant. */
+      certificate: z26.string().nullable().optional(),
+      /** The current credential's profile, or null with none (signed out or revoked). */
+      profile: profile.optional(),
+      /** True for the device whose credential made this request. */
+      current: z26.boolean().default(false),
+      projects: z26.number().int().nonnegative().optional(),
+      replicas: z26.number().int().nonnegative().optional(),
+      lastSyncAt: isoTime.nullable().optional(),
+      lastPresenceAt: isoTime.nullable().optional()
+    });
+    nexusCloudOrganizationSchema = z26.object({
+      id: z26.string(),
+      name: z26.string(),
+      slug: z26.string().nullable().optional(),
+      role: z26.string().optional(),
+      personal: z26.boolean().optional()
+    });
+    nexusCloudUserSchema = z26.object({
+      id: z26.string(),
+      email: z26.string(),
+      name: z26.string().nullable().optional()
+    });
+    nexusCloudWhoamiSchema = z26.object({
+      serverTime: isoTime.optional(),
+      user: nexusCloudUserSchema,
+      organizations: z26.array(nexusCloudOrganizationSchema).default([]),
+      credential: nexusCloudCredentialSchema,
+      /** The calling device; null for a session caller. */
+      device: nexusCloudDeviceSchema.nullable()
+    });
+    nexusCloudDevicePageSchema = z26.object({
+      devices: z26.array(nexusCloudDeviceSchema),
+      nextCursor: z26.string().max(512).nullable().default(null),
+      truncated: z26.boolean().default(false)
+    });
+    nexusCloudPresenceSchema = z26.looseObject({
+      observedAt: isoTime.optional(),
+      sync: z26.object({ enabled: z26.boolean() }).optional()
+    });
+    nexusCloudReplicaSchema = z26.object({
+      projectId: z26.string(),
+      replicaId: z26.string(),
+      deviceId: z26.string(),
+      deviceName: z26.string(),
+      deviceState: deviceState.optional(),
+      attachedAt: isoTime.optional(),
+      lastSyncAt: isoTime.nullable(),
+      presence: nexusCloudPresenceSchema.nullable(),
+      presenceAt: isoTime.nullable()
+    });
+    nexusCloudDeviceCountsSchema = z26.object({
+      active: z26.number().int().nonnegative(),
+      total: z26.number().int().nonnegative()
+    });
+    projectFields = {
+      projectId: z26.string(),
+      label: z26.string().nullable(),
+      organizationId: z26.string(),
+      organizationName: z26.string().optional(),
+      remoteUrl: z26.string().nullable().optional(),
+      createdAt: isoTime.optional()
+    };
+    nexusCloudProjectListItemSchema = z26.object({
+      ...projectFields,
+      role: z26.string(),
+      streamId: z26.string().optional(),
+      headSeq: z26.number().int().nonnegative().nullable().optional(),
+      openConflicts: z26.number().int().nonnegative().optional(),
+      replicas: z26.array(nexusCloudReplicaSchema).default([]),
+      devices: nexusCloudDeviceCountsSchema.optional(),
+      replicaCount: z26.number().int().nonnegative().optional(),
+      lastSyncAt: isoTime.nullable().optional(),
+      lastPresenceAt: isoTime.nullable().optional(),
+      /** This project's replica list was cut at 50 (T12858). */
+      replicasTruncated: z26.boolean().default(false)
+    });
+    nexusCloudProjectPageSchema = z26.object({
+      projects: z26.array(nexusCloudProjectListItemSchema),
+      nextCursor: z26.string().max(512).nullable().default(null),
+      /** Anything in the page was cut (the project list or a replica list). */
+      truncated: z26.boolean().default(false),
+      /** The project list itself was cut at 1000 (T12858). */
+      projectsTruncated: z26.boolean().default(false)
+    });
+    nexusCloudProjectDetailSchema = z26.object({
+      project: z26.object({ ...projectFields, deletedAt: isoTime.nullable().optional() }),
+      role: z26.string(),
+      canTrash: z26.boolean().optional(),
+      openConflicts: z26.number().int().nonnegative(),
+      /** At most 50, oldest attachment first. */
+      replicas: z26.array(nexusCloudReplicaSchema),
+      devices: nexusCloudDeviceCountsSchema,
+      replicaCount: z26.number().int().nonnegative().optional(),
+      lastSyncAt: isoTime.nullable().optional(),
+      /** `replicas` was cut at 50. */
+      truncated: z26.boolean().default(false),
+      stream: z26.object({
+        streamId: z26.string(),
+        headSeq: z26.number().int().nonnegative(),
+        headCheckpointId: z26.string().nullable()
+      }).nullable()
+    });
+    nexusCloudReplicaPageSchema = z26.object({
+      replicas: z26.array(nexusCloudReplicaSchema),
+      devices: nexusCloudDeviceCountsSchema.optional(),
+      nextCursor: z26.string().max(512).nullable().default(null),
+      truncated: z26.boolean().default(false)
+    });
+    NEXUS_STATUS_CHECK_IDS = [
+      "credential.valid",
+      "device.registered",
+      "device.active",
+      "device.certified",
+      "project.registered",
+      "project.writable",
+      "replica.attached",
+      "presence.fresh",
+      "replica.synced",
+      "conflicts.none"
+    ];
+    NEXUS_STATUS_VERDICTS = ["ok", "attention", "not-linked", "not-registered"];
+    CLOUD_STATUS_VERDICTS = [...NEXUS_STATUS_VERDICTS, "not-signed-in"];
+    knownCheckId = z26.enum(NEXUS_STATUS_CHECK_IDS);
+    nexusCloudStatusCheckSchema = z26.object({
+      id: z26.enum(NEXUS_STATUS_CHECK_IDS),
+      ok: z26.boolean(),
+      required: z26.boolean(),
+      detail: z26.string()
+    });
+    nexusCloudStatusSchema = z26.object({
+      serverTime: isoTime.optional(),
+      apiVersion: z26.string().optional(),
+      user: nexusCloudUserSchema,
+      credential: nexusCloudCredentialSchema,
+      device: nexusCloudDeviceSchema.nullable(),
+      project: z26.object({
+        projectId: z26.string(),
+        registered: z26.boolean(),
+        organizationId: z26.string().nullable(),
+        organizationName: z26.string().nullable(),
+        role: z26.string().nullable()
+      }).nullable(),
+      replica: z26.object({
+        replicaId: z26.string(),
+        attached: z26.boolean(),
+        attachedElsewhere: z26.boolean(),
+        attachedAt: isoTime.nullable(),
+        lastSyncAt: isoTime.nullable(),
+        presenceAt: isoTime.nullable(),
+        lastReplicaSeq: z26.number().int().nonnegative().nullable().optional()
+      }).nullable(),
+      stream: z26.object({
+        streamId: z26.string(),
+        headSeq: z26.number().int().nonnegative(),
+        headCheckpointId: z26.string().nullable(),
+        openConflicts: z26.number().int().nonnegative(),
+        devices: nexusCloudDeviceCountsSchema
+      }).nullable(),
+      /** Check ids added by a newer server are dropped, never a parse failure. */
+      checks: z26.array(nexusCloudStatusCheckSchema.extend({ id: z26.string() })).transform(
+        (list) => list.flatMap((c) => {
+          const id = knownCheckId.safeParse(c.id);
+          return id.success ? [{ ...c, id: id.data }] : [];
+        })
+      ),
+      /** A verdict added by a newer server reads as `attention`: never `ok` by accident. */
+      verdict: z26.enum(NEXUS_STATUS_VERDICTS).catch("attention")
+    });
+  }
+});
+
 // packages/contracts/src/task-id.ts
 var init_task_id = __esm({
   "packages/contracts/src/task-id.ts"() {
@@ -17547,6 +17751,7 @@ var init_src = __esm({
     init_decide();
     init_decide_sites();
     init_nexus_account();
+    init_nexus_cloud();
     init_task_id();
   }
 });
@@ -33295,7 +33500,7 @@ var init_task_claim = __esm({
 });
 
 // packages/core/src/store/converters.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 function readStoredAcceptance(row) {
   if (row.acceptanceJson === null || row.acceptanceJson === void 0) return void 0;
   try {
@@ -33453,7 +33658,7 @@ var init_converters = __esm({
     init_src();
     init_parsers();
     init_task_claim();
-    storedAcceptanceSchema = z26.custom(
+    storedAcceptanceSchema = z27.custom(
       (value) => Array.isArray(value) && value.every((item) => acceptanceItemSchema.safeParse(item).success)
     );
   }
@@ -36116,7 +36321,7 @@ import {
 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
 import { basename as basename7, dirname as dirname12, join as join13 } from "node:path";
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 function formatBackupTimestamp(d) {
   const pad = (n, len = 2) => String(n).padStart(len, "0");
   return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
@@ -36253,16 +36458,16 @@ var init_backup_sidecar = __esm({
     init_logger2();
     PRE_COLLAPSE_BACKUP_TYPE = "migration";
     MARKER_PREFIX = "twin_collapse:";
-    backupSidecarSchema = z27.object({
-      backupId: z27.string().min(1),
-      type: z27.string().min(1),
-      timestamp: z27.string().min(1),
-      note: z27.string().optional(),
-      files: z27.array(z27.string()),
-      pinned: z27.boolean().optional(),
-      pinnedReason: z27.string().optional(),
-      releasedAt: z27.string().optional(),
-      releasedReason: z27.string().optional()
+    backupSidecarSchema = z28.object({
+      backupId: z28.string().min(1),
+      type: z28.string().min(1),
+      timestamp: z28.string().min(1),
+      note: z28.string().optional(),
+      files: z28.array(z28.string()),
+      pinned: z28.boolean().optional(),
+      pinnedReason: z28.string().optional(),
+      releasedAt: z28.string().optional(),
+      releasedReason: z28.string().optional()
     }).passthrough();
   }
 });
@@ -36434,7 +36639,7 @@ var init_pre_repair_snapshot = __esm({
 import { createHash as createHash5 } from "node:crypto";
 import { basename as basename8, dirname as dirname15 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 function hasMainTable(db, name15) {
   return db.prepare("SELECT 1 FROM main.sqlite_master WHERE type = 'table' AND name = ?").get(name15) !== void 0;
 }
@@ -37567,20 +37772,20 @@ var init_twin_collapse = __esm({
     SHADOW_WRITE_REFUSED = "E_TWIN_COLLAPSE_FAILED: store is read-only until the twin collapse succeeds; run cleo doctor twin-collapse";
     SHADOW_WRITE_OPS = ["INSERT", "UPDATE", "DELETE"];
     STICKY_ARCHIVE_KEY = `${TWIN_COLLAPSE_ARCHIVE_PREFIX}sticky_tags`;
-    FocusNotesShape = z28.object({ sessionNotes: z28.array(z28.unknown()) }).passthrough();
-    StickyArchiveShape = z28.array(z28.string());
-    RecoveryReceiptShape = z28.object({
-      task: z28.literal("T12727"),
-      id: z28.string(),
-      recoveredAt: z28.string(),
-      snapshot: z28.string().nullable(),
-      archived: z28.array(z28.object({ key: z28.string(), archiveKey: z28.string(), sha: z28.string() })),
-      focusNotesAdded: z28.number(),
-      stickyArchived: z28.array(z28.string()),
-      stickyArchiveKey: z28.string(),
-      before: z28.object({ focusState: z28.string().nullable(), stickyArchive: z28.string().nullable() }),
-      after: z28.object({ focusState: z28.string().nullable(), stickyArchive: z28.string().nullable() }),
-      rolledBackAt: z28.string().nullable()
+    FocusNotesShape = z29.object({ sessionNotes: z29.array(z29.unknown()) }).passthrough();
+    StickyArchiveShape = z29.array(z29.string());
+    RecoveryReceiptShape = z29.object({
+      task: z29.literal("T12727"),
+      id: z29.string(),
+      recoveredAt: z29.string(),
+      snapshot: z29.string().nullable(),
+      archived: z29.array(z29.object({ key: z29.string(), archiveKey: z29.string(), sha: z29.string() })),
+      focusNotesAdded: z29.number(),
+      stickyArchived: z29.array(z29.string()),
+      stickyArchiveKey: z29.string(),
+      before: z29.object({ focusState: z29.string().nullable(), stickyArchive: z29.string().nullable() }),
+      after: z29.object({ focusState: z29.string().nullable(), stickyArchive: z29.string().nullable() }),
+      rolledBackAt: z29.string().nullable()
     });
   }
 });
@@ -45304,7 +45509,7 @@ var init_governor = __esm({
 // packages/core/src/store/exodus/recovery.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { constants } from "node:sqlite";
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 function identityValues(encoded) {
   return identitySchema.parse(JSON.parse(encoded)).map(([kind, value]) => {
     if (kind === "null") return null;
@@ -45640,8 +45845,8 @@ var init_recovery = __esm({
     "use strict";
     init_row_identity_registry();
     RECEIPTS = "_exodus_recovery_rows";
-    identitySchema = z29.array(
-      z29.tuple([z29.enum(["null", "integer", "real", "text", "blob"]), z29.string()])
+    identitySchema = z30.array(
+      z30.tuple([z30.enum(["null", "integer", "real", "text", "blob"]), z30.string()])
     );
     ExodusRecoveryError = class extends Error {
     };
@@ -45659,7 +45864,7 @@ import {
   writeFileSync as writeFileSync6
 } from "node:fs";
 import { basename as basename9, dirname as dirname19, join as join26, resolve as resolve12 } from "node:path";
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 function scopeBaseDir(scope, cwd, targetDbPath) {
   if (targetDbPath !== void 0) return dirname19(targetDbPath);
   return scope === "project" ? resolveCleoDir(cwd) : getCleoHome();
@@ -45802,11 +46007,11 @@ var init_archive2 = __esm({
     init_ensure_config();
     init_recovery();
     log8 = getLogger("exodus-archive");
-    markerIdentity = z30.object({
-      version: z30.literal(1),
-      scope: z30.enum(["project", "global"]),
-      targetDbPath: z30.string().optional(),
-      databaseIdentity: z30.string().optional()
+    markerIdentity = z31.object({
+      version: z31.literal(1),
+      scope: z31.enum(["project", "global"]),
+      targetDbPath: z31.string().optional(),
+      databaseIdentity: z31.string().optional()
     });
     ARCHIVE_DIR_NAME = "_archive";
     MARKER_FILENAME_BY_SCOPE = {
@@ -53755,8 +53960,8 @@ async function scanAndLoadPlugins(pluginDir, api) {
 }
 async function runDiscovery(registerProvider2, builtins) {
   const api = { registerProvider: registerProvider2 };
-  for (const profile of builtins) {
-    registerProvider2(profile);
+  for (const profile2 of builtins) {
+    registerProvider2(profile2);
   }
   await scanAndLoadPlugins(getPluginDir(), api);
 }
@@ -53779,16 +53984,16 @@ __export(provider_registry_exports, {
   listProviders: () => listProviders,
   registerProvider: () => registerProvider
 });
-function registerProvider(profile) {
-  const key = profile.name.toLowerCase();
-  _registry.set(key, profile);
-  for (const alias of profile.aliases ?? []) {
+function registerProvider(profile2) {
+  const key = profile2.name.toLowerCase();
+  _registry.set(key, profile2);
+  for (const alias of profile2.aliases ?? []) {
     const aliasKey = alias.toLowerCase();
     const existing = _aliases.get(aliasKey);
     if (existing !== void 0 && existing !== key) {
       if (_registry.has(aliasKey) && aliasKey !== key) {
         throw new TypeError(
-          `[provider-registry] Alias "${alias}" for provider "${profile.name}" conflicts with the primary name of provider "${_registry.get(aliasKey)?.name ?? aliasKey}".`
+          `[provider-registry] Alias "${alias}" for provider "${profile2.name}" conflicts with the primary name of provider "${_registry.get(aliasKey)?.name ?? aliasKey}".`
         );
       }
     }
@@ -54261,8 +54466,8 @@ var init_credential_pool = __esm({
        */
       async _refreshOAuthCredential(existing) {
         if (!existing.refreshToken) return;
-        const profile = await getProviderProfile(this.provider);
-        const oauthCfg = profile?.oauth;
+        const profile2 = await getProviderProfile(this.provider);
+        const oauthCfg = profile2?.oauth;
         if (oauthCfg?.mode === "pkce") {
           await this._refreshViaPkce(
             existing,
@@ -56213,7 +56418,7 @@ var init_structured_output = __esm({
 
 // packages/core/src/llm/transports/anthropic.ts
 import Anthropic from "@anthropic-ai/sdk";
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 function isTextBlock(block) {
   return block.type === "text";
 }
@@ -56285,8 +56490,8 @@ function mapUsage(usage) {
 function zodSchemaFrom(responseFormat) {
   if (responseFormat == null) return null;
   const asAny = responseFormat;
-  if (asAny["schema"] instanceof z31.ZodType) return asAny["schema"];
-  if (responseFormat instanceof z31.ZodType) return responseFormat;
+  if (asAny["schema"] instanceof z32.ZodType) return asAny["schema"];
+  if (responseFormat instanceof z32.ZodType) return responseFormat;
   return null;
 }
 function getJsonSchemaString(responseFormat) {
@@ -56692,7 +56897,7 @@ ${schemaJson}`
             content = typeof validated === "string" ? validated : JSON.stringify(validated);
           } catch {
             try {
-              const repaired = repairResponseModelJson(rawContent, zodSchema2 ?? z31.unknown(), modelName);
+              const repaired = repairResponseModelJson(rawContent, zodSchema2 ?? z32.unknown(), modelName);
               content = typeof repaired === "string" ? repaired : JSON.stringify(repaired);
             } catch {
               content = rawContent || null;
@@ -58257,7 +58462,7 @@ var init_caching = __esm({
 
 // packages/core/src/llm/transports/gemini.ts
 import { GoogleGenerativeAI } from "@google/generative-ai";
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 function messagesToRaw(messages, system) {
   const raw = [];
   if (system) {
@@ -58645,7 +58850,7 @@ var init_gemini2 = __esm({
         const parsed = response["parsed"];
         if (parsed !== null && parsed !== void 0) {
           try {
-            const zodResult = z32.string().safeParse(String(parsed));
+            const zodResult = z33.string().safeParse(String(parsed));
             if (!zodResult.success) {
               content = JSON.stringify(parsed);
             } else {
@@ -73042,7 +73247,7 @@ function resolveRef2(ref, ctx) {
 function convertBaseSchema(schema, ctx) {
   if (schema.not !== void 0) {
     if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) {
-      return z33.never();
+      return z34.never();
     }
     throw new Error("not is not supported in Zod (except { not: {} } for never)");
   }
@@ -73064,7 +73269,7 @@ function convertBaseSchema(schema, ctx) {
       return ctx.refs.get(refPath);
     }
     if (ctx.processing.has(refPath)) {
-      return z33.lazy(() => {
+      return z34.lazy(() => {
         if (!ctx.refs.has(refPath)) {
           throw new Error(`Circular reference not resolved: ${refPath}`);
         }
@@ -73081,25 +73286,25 @@ function convertBaseSchema(schema, ctx) {
   if (schema.enum !== void 0) {
     const enumValues = schema.enum;
     if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
-      return z33.null();
+      return z34.null();
     }
     if (enumValues.length === 0) {
-      return z33.never();
+      return z34.never();
     }
     if (enumValues.length === 1) {
-      return z33.literal(enumValues[0]);
+      return z34.literal(enumValues[0]);
     }
     if (enumValues.every((v) => typeof v === "string")) {
-      return z33.enum(enumValues);
+      return z34.enum(enumValues);
     }
-    const literalSchemas = enumValues.map((v) => z33.literal(v));
+    const literalSchemas = enumValues.map((v) => z34.literal(v));
     if (literalSchemas.length < 2) {
       return literalSchemas[0];
     }
-    return z33.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
+    return z34.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
   }
   if (schema.const !== void 0) {
-    return z33.literal(schema.const);
+    return z34.literal(schema.const);
   }
   const type = schema.type;
   if (Array.isArray(type)) {
@@ -73108,68 +73313,68 @@ function convertBaseSchema(schema, ctx) {
       return convertBaseSchema(typeSchema, ctx);
     });
     if (typeSchemas.length === 0) {
-      return z33.never();
+      return z34.never();
     }
     if (typeSchemas.length === 1) {
       return typeSchemas[0];
     }
-    return z33.union(typeSchemas);
+    return z34.union(typeSchemas);
   }
   if (!type) {
-    return z33.any();
+    return z34.any();
   }
   let zodSchema2;
   switch (type) {
     case "string": {
-      let stringSchema = z33.string();
+      let stringSchema = z34.string();
       if (schema.format) {
         const format = schema.format;
         if (format === "email") {
-          stringSchema = stringSchema.check(z33.email());
+          stringSchema = stringSchema.check(z34.email());
         } else if (format === "uri" || format === "uri-reference") {
-          stringSchema = stringSchema.check(z33.url());
+          stringSchema = stringSchema.check(z34.url());
         } else if (format === "uuid" || format === "guid") {
-          stringSchema = stringSchema.check(z33.uuid());
+          stringSchema = stringSchema.check(z34.uuid());
         } else if (format === "date-time") {
-          stringSchema = stringSchema.check(z33.iso.datetime());
+          stringSchema = stringSchema.check(z34.iso.datetime());
         } else if (format === "date") {
-          stringSchema = stringSchema.check(z33.iso.date());
+          stringSchema = stringSchema.check(z34.iso.date());
         } else if (format === "time") {
-          stringSchema = stringSchema.check(z33.iso.time());
+          stringSchema = stringSchema.check(z34.iso.time());
         } else if (format === "duration") {
-          stringSchema = stringSchema.check(z33.iso.duration());
+          stringSchema = stringSchema.check(z34.iso.duration());
         } else if (format === "ipv4") {
-          stringSchema = stringSchema.check(z33.ipv4());
+          stringSchema = stringSchema.check(z34.ipv4());
         } else if (format === "ipv6") {
-          stringSchema = stringSchema.check(z33.ipv6());
+          stringSchema = stringSchema.check(z34.ipv6());
         } else if (format === "mac") {
-          stringSchema = stringSchema.check(z33.mac());
+          stringSchema = stringSchema.check(z34.mac());
         } else if (format === "cidr") {
-          stringSchema = stringSchema.check(z33.cidrv4());
+          stringSchema = stringSchema.check(z34.cidrv4());
         } else if (format === "cidr-v6") {
-          stringSchema = stringSchema.check(z33.cidrv6());
+          stringSchema = stringSchema.check(z34.cidrv6());
         } else if (format === "base64") {
-          stringSchema = stringSchema.check(z33.base64());
+          stringSchema = stringSchema.check(z34.base64());
         } else if (format === "base64url") {
-          stringSchema = stringSchema.check(z33.base64url());
+          stringSchema = stringSchema.check(z34.base64url());
         } else if (format === "e164") {
-          stringSchema = stringSchema.check(z33.e164());
+          stringSchema = stringSchema.check(z34.e164());
         } else if (format === "jwt") {
-          stringSchema = stringSchema.check(z33.jwt());
+          stringSchema = stringSchema.check(z34.jwt());
         } else if (format === "emoji") {
-          stringSchema = stringSchema.check(z33.emoji());
+          stringSchema = stringSchema.check(z34.emoji());
         } else if (format === "nanoid") {
-          stringSchema = stringSchema.check(z33.nanoid());
+          stringSchema = stringSchema.check(z34.nanoid());
         } else if (format === "cuid") {
-          stringSchema = stringSchema.check(z33.cuid());
+          stringSchema = stringSchema.check(z34.cuid());
         } else if (format === "cuid2") {
-          stringSchema = stringSchema.check(z33.cuid2());
+          stringSchema = stringSchema.check(z34.cuid2());
         } else if (format === "ulid") {
-          stringSchema = stringSchema.check(z33.ulid());
+          stringSchema = stringSchema.check(z34.ulid());
         } else if (format === "xid") {
-          stringSchema = stringSchema.check(z33.xid());
+          stringSchema = stringSchema.check(z34.xid());
         } else if (format === "ksuid") {
-          stringSchema = stringSchema.check(z33.ksuid());
+          stringSchema = stringSchema.check(z34.ksuid());
         }
       }
       if (typeof schema.minLength === "number") {
@@ -73186,7 +73391,7 @@ function convertBaseSchema(schema, ctx) {
     }
     case "number":
     case "integer": {
-      let numberSchema = type === "integer" ? z33.number().int() : z33.number();
+      let numberSchema = type === "integer" ? z34.number().int() : z34.number();
       if (typeof schema.minimum === "number") {
         numberSchema = numberSchema.min(schema.minimum);
       }
@@ -73210,11 +73415,11 @@ function convertBaseSchema(schema, ctx) {
       break;
     }
     case "boolean": {
-      zodSchema2 = z33.boolean();
+      zodSchema2 = z34.boolean();
       break;
     }
     case "null": {
-      zodSchema2 = z33.null();
+      zodSchema2 = z34.null();
       break;
     }
     case "object": {
@@ -73227,14 +73432,14 @@ function convertBaseSchema(schema, ctx) {
       }
       if (schema.propertyNames) {
         const keySchema = convertSchema(schema.propertyNames, ctx);
-        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z33.any();
+        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z34.any();
         if (Object.keys(shape).length === 0) {
-          zodSchema2 = z33.record(keySchema, valueSchema);
+          zodSchema2 = z34.record(keySchema, valueSchema);
           break;
         }
-        const objectSchema2 = z33.object(shape).passthrough();
-        const recordSchema = z33.looseRecord(keySchema, valueSchema);
-        zodSchema2 = z33.intersection(objectSchema2, recordSchema);
+        const objectSchema2 = z34.object(shape).passthrough();
+        const recordSchema = z34.looseRecord(keySchema, valueSchema);
+        zodSchema2 = z34.intersection(objectSchema2, recordSchema);
         break;
       }
       if (schema.patternProperties) {
@@ -73243,28 +73448,28 @@ function convertBaseSchema(schema, ctx) {
         const looseRecords = [];
         for (const pattern of patternKeys) {
           const patternValue = convertSchema(patternProps[pattern], ctx);
-          const keySchema = z33.string().regex(new RegExp(pattern));
-          looseRecords.push(z33.looseRecord(keySchema, patternValue));
+          const keySchema = z34.string().regex(new RegExp(pattern));
+          looseRecords.push(z34.looseRecord(keySchema, patternValue));
         }
         const schemasToIntersect = [];
         if (Object.keys(shape).length > 0) {
-          schemasToIntersect.push(z33.object(shape).passthrough());
+          schemasToIntersect.push(z34.object(shape).passthrough());
         }
         schemasToIntersect.push(...looseRecords);
         if (schemasToIntersect.length === 0) {
-          zodSchema2 = z33.object({}).passthrough();
+          zodSchema2 = z34.object({}).passthrough();
         } else if (schemasToIntersect.length === 1) {
           zodSchema2 = schemasToIntersect[0];
         } else {
-          let result = z33.intersection(schemasToIntersect[0], schemasToIntersect[1]);
+          let result = z34.intersection(schemasToIntersect[0], schemasToIntersect[1]);
           for (let i = 2; i < schemasToIntersect.length; i++) {
-            result = z33.intersection(result, schemasToIntersect[i]);
+            result = z34.intersection(result, schemasToIntersect[i]);
           }
           zodSchema2 = result;
         }
         break;
       }
-      const objectSchema = z33.object(shape);
+      const objectSchema = z34.object(shape);
       if (schema.additionalProperties === false) {
         zodSchema2 = objectSchema.strict();
       } else if (typeof schema.additionalProperties === "object") {
@@ -73281,33 +73486,33 @@ function convertBaseSchema(schema, ctx) {
         const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
         const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : void 0;
         if (rest) {
-          zodSchema2 = z33.tuple(tupleItems).rest(rest);
+          zodSchema2 = z34.tuple(tupleItems).rest(rest);
         } else {
-          zodSchema2 = z33.tuple(tupleItems);
+          zodSchema2 = z34.tuple(tupleItems);
         }
         if (typeof schema.minItems === "number") {
-          zodSchema2 = zodSchema2.check(z33.minLength(schema.minItems));
+          zodSchema2 = zodSchema2.check(z34.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema2 = zodSchema2.check(z33.maxLength(schema.maxItems));
+          zodSchema2 = zodSchema2.check(z34.maxLength(schema.maxItems));
         }
       } else if (Array.isArray(items)) {
         const tupleItems = items.map((item) => convertSchema(item, ctx));
         const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx) : void 0;
         if (rest) {
-          zodSchema2 = z33.tuple(tupleItems).rest(rest);
+          zodSchema2 = z34.tuple(tupleItems).rest(rest);
         } else {
-          zodSchema2 = z33.tuple(tupleItems);
+          zodSchema2 = z34.tuple(tupleItems);
         }
         if (typeof schema.minItems === "number") {
-          zodSchema2 = zodSchema2.check(z33.minLength(schema.minItems));
+          zodSchema2 = zodSchema2.check(z34.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema2 = zodSchema2.check(z33.maxLength(schema.maxItems));
+          zodSchema2 = zodSchema2.check(z34.maxLength(schema.maxItems));
         }
       } else if (items !== void 0) {
         const element = convertSchema(items, ctx);
-        let arraySchema = z33.array(element);
+        let arraySchema = z34.array(element);
         if (typeof schema.minItems === "number") {
           arraySchema = arraySchema.min(schema.minItems);
         }
@@ -73316,7 +73521,7 @@ function convertBaseSchema(schema, ctx) {
         }
         zodSchema2 = arraySchema;
       } else {
-        zodSchema2 = z33.array(z33.any());
+        zodSchema2 = z34.array(z34.any());
       }
       break;
     }
@@ -73333,37 +73538,37 @@ function convertBaseSchema(schema, ctx) {
 }
 function convertSchema(schema, ctx) {
   if (typeof schema === "boolean") {
-    return schema ? z33.any() : z33.never();
+    return schema ? z34.any() : z34.never();
   }
   let baseSchema = convertBaseSchema(schema, ctx);
   const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
   if (schema.anyOf && Array.isArray(schema.anyOf)) {
     const options = schema.anyOf.map((s) => convertSchema(s, ctx));
-    const anyOfUnion = z33.union(options);
-    baseSchema = hasExplicitType ? z33.intersection(baseSchema, anyOfUnion) : anyOfUnion;
+    const anyOfUnion = z34.union(options);
+    baseSchema = hasExplicitType ? z34.intersection(baseSchema, anyOfUnion) : anyOfUnion;
   }
   if (schema.oneOf && Array.isArray(schema.oneOf)) {
     const options = schema.oneOf.map((s) => convertSchema(s, ctx));
-    const oneOfUnion = z33.xor(options);
-    baseSchema = hasExplicitType ? z33.intersection(baseSchema, oneOfUnion) : oneOfUnion;
+    const oneOfUnion = z34.xor(options);
+    baseSchema = hasExplicitType ? z34.intersection(baseSchema, oneOfUnion) : oneOfUnion;
   }
   if (schema.allOf && Array.isArray(schema.allOf)) {
     if (schema.allOf.length === 0) {
-      baseSchema = hasExplicitType ? baseSchema : z33.any();
+      baseSchema = hasExplicitType ? baseSchema : z34.any();
     } else {
       let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
       const startIdx = hasExplicitType ? 0 : 1;
       for (let i = startIdx; i < schema.allOf.length; i++) {
-        result = z33.intersection(result, convertSchema(schema.allOf[i], ctx));
+        result = z34.intersection(result, convertSchema(schema.allOf[i], ctx));
       }
       baseSchema = result;
     }
   }
   if (schema.nullable === true && ctx.version === "openapi-3.0") {
-    baseSchema = z33.nullable(baseSchema);
+    baseSchema = z34.nullable(baseSchema);
   }
   if (schema.readOnly === true) {
-    baseSchema = z33.readonly(baseSchema);
+    baseSchema = z34.readonly(baseSchema);
   }
   const extraMeta = {};
   const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
@@ -73390,7 +73595,7 @@ function convertSchema(schema, ctx) {
 }
 function fromJSONSchema(schema, params) {
   if (typeof schema === "boolean") {
-    return schema ? z33.any() : z33.never();
+    return schema ? z34.any() : z34.never();
   }
   const version2 = detectVersion(schema, params?.defaultTarget);
   const defs = schema.$defs || schema.definitions || {};
@@ -73404,14 +73609,14 @@ function fromJSONSchema(schema, params) {
   };
   return convertSchema(schema, ctx);
 }
-var z33, RECOGNIZED_KEYS;
+var z34, RECOGNIZED_KEYS;
 var init_from_json_schema = __esm({
   "node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/from-json-schema.js"() {
     init_registries();
     init_checks2();
     init_iso();
     init_schemas2();
-    z33 = {
+    z34 = {
       ...schemas_exports2,
       ...checks_exports2,
       iso: iso_exports
@@ -87324,15 +87529,15 @@ async function selectBestProvisioned(role, opts) {
   const ollamaProvisioned = provisionedIds.includes("ollama");
   let ollamaAlive = localModels.length > 0;
   if (ollamaProvisioned && !ollamaAlive) {
-    const profile = await getProviderProfile2("ollama");
-    const ollamaBase = profile?.baseUrl ?? "http://localhost:11434";
+    const profile2 = await getProviderProfile2("ollama");
+    const ollamaBase = profile2?.baseUrl ?? "http://localhost:11434";
     ollamaAlive = await probeOllamaAlive(ollamaBase);
     if (ollamaAlive) localModels = await listOllamaModels(ollamaBase);
   }
   const scored = [];
   for (const id of provisionedIds) {
-    const profile = await getProviderProfile2(id);
-    const tier = profile?.tier ?? "standard";
+    const profile2 = await getProviderProfile2(id);
+    const tier = profile2?.tier ?? "standard";
     const costInput = 0;
     const score = scoreProvider(id, tier, taskTier, ollamaAlive, costInput);
     const storedCred = await pickCredentialForProvider2(id, { strategy: "priorityOnly" });
@@ -87527,12 +87732,12 @@ function readLlmBlock(config2) {
 }
 function resolveNamedProfile(llm, name15, source) {
   if (!name15) return void 0;
-  const profile = llm?.profiles?.[name15];
-  if (!profile?.provider || !profile.model) return void 0;
+  const profile2 = llm?.profiles?.[name15];
+  if (!profile2?.provider || !profile2.model) return void 0;
   return {
-    provider: profile.provider,
-    model: profile.model,
-    credentialLabel: profile.credentialLabel,
+    provider: profile2.provider,
+    model: profile2.model,
+    credentialLabel: profile2.credentialLabel,
     source
   };
 }
@@ -87560,11 +87765,11 @@ function resolveSystemBinding(llm, systemKey) {
 function resolveRegisteredSystemDefault(llm, systemKey) {
   const defaults = getRegisteredSystemDefault(systemKey);
   if (!defaults) return void 0;
-  const profile = resolveNamedProfile(llm, defaults.profile, "registered-default");
-  if (profile) {
+  const profile2 = resolveNamedProfile(llm, defaults.profile, "registered-default");
+  if (profile2) {
     return {
-      ...profile,
-      credentialLabel: defaults.credentialLabel ?? profile.credentialLabel
+      ...profile2,
+      credentialLabel: defaults.credentialLabel ?? profile2.credentialLabel
     };
   }
   if (defaults.provider && defaults.model) {