@cleocode/core 2026.9.26 → 2026.10.1

package/dist/docs/export-document.js

@@ -17366,6 +17366,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"() {
@@ -17450,6 +17654,7 @@ var init_src = __esm({
     init_decide();
     init_decide_sites();
     init_nexus_account();
+    init_nexus_cloud();
     init_task_id();
   }
 });
@@ -33198,7 +33403,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 {
@@ -33356,7 +33561,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)
     );
   }
@@ -36019,7 +36224,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())}`;
@@ -36156,16 +36361,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();
   }
 });
@@ -36337,7 +36542,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, name2) {
   return db.prepare("SELECT 1 FROM main.sqlite_master WHERE type = 'table' AND name = ?").get(name2) !== void 0;
 }
@@ -37470,20 +37675,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()
     });
   }
 });
@@ -45207,7 +45412,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;
@@ -45543,8 +45748,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 {
     };
@@ -45562,7 +45767,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();
@@ -45705,11 +45910,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 = {