@opengeni/contracts 5.5.0 → 5.5.2-canary.40656248492001

package/src/sandbox-provider-command.ts

@@ -1,82 +1,65 @@
+import * as primitives from "./primitives";
+import { defineSchema } from "./define-schema";
 import { z } from "zod";
 
-const ModalOutputCursor = z
-  .object({
-    batchIndex: z.number().int().nonnegative().safe(),
-    utf8Remainder: z
-      .string()
-      .max(8)
-      .regex(/^[A-Za-z0-9+/]*={0,2}$/u),
-    exitCode: z.number().int().nullable(),
-  })
-  .strict();
+const ModalByteCursor = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      byteOffset: primitives.nonnegativeInteger.safe(),
+      utf8Remainder: z
+        .string()
+        .max(8)
+        .regex(/^[A-Za-z0-9+/]*={0,2}$/u),
+      eof: primitives.boolean,
+      exitCode: z.number().int().nullable(),
+    })
+    .strict()
+    .refine((cursor) => cursor.exitCode === null || cursor.eof, {
+      message: "A terminal output cursor must have reached EOF",
+    }),
+);
 
-/** Provider-owned execution identity and acknowledged output cursors. These
- * values are retained by the control plane, never recovered from sandbox files. */
-export const ModalLegacyProviderCommand = z
-  .object({
-    kind: z.literal("modal-control-v1"),
-    sandboxId: z.string().min(1).max(200),
-    taskId: z.string().min(1).max(200),
-    execId: z.string().min(1).max(200),
-    pty: z.boolean().optional(),
-    streams: z.object({ stdout: ModalOutputCursor, stderr: ModalOutputCursor }).strict(),
-  })
-  .strict();
-export type ModalLegacyProviderCommand = z.infer<typeof ModalLegacyProviderCommand>;
-
-const ModalByteCursor = z
-  .object({
-    byteOffset: z.number().int().nonnegative().safe(),
-    utf8Remainder: z
-      .string()
-      .max(8)
-      .regex(/^[A-Za-z0-9+/]*={0,2}$/u),
-    eof: z.boolean(),
-    exitCode: z.number().int().nullable(),
-  })
-  .strict()
-  .refine((cursor) => cursor.exitCode === null || cursor.eof, {
-    message: "A terminal output cursor must have reached EOF",
-  });
-
-export const CommandSupervisionDescriptor = z
-  .object({
-    protocol: z.literal("native-subreaper-v1"),
-    invocationId: z.string().uuid(),
-    nonce: z.string().regex(/^[a-f0-9]{64}$/u),
-    controlPath: z.string().regex(/^\/tmp\/opengeni-supervision\/[a-f0-9-]{36}\.sock$/u),
-  })
-  .strict();
+export const CommandSupervisionDescriptor = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      protocol: z.literal("native-subreaper-v1"),
+      invocationId: primitives.uuid,
+      nonce: primitives.string.regex(/^[a-f0-9]{64}$/u),
+      controlPath: primitives.string.regex(/^\/tmp\/opengeni-supervision\/[a-f0-9-]{36}\.sock$/u),
+    })
+    .strict(),
+);
 export type CommandSupervisionDescriptor = z.infer<typeof CommandSupervisionDescriptor>;
 
-export const CommandSupervisionReceipt = z
-  .object({
-    protocol: z.literal("native-subreaper-v1"),
-    invocationId: z.string().uuid(),
-    receiptId: z.string().uuid(),
-    leaderExitCode: z.number().int(),
-  })
-  .strict();
+export const CommandSupervisionReceipt = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      protocol: z.literal("native-subreaper-v1"),
+      invocationId: primitives.uuid,
+      receiptId: primitives.uuid,
+      leaderExitCode: z.number().int(),
+    })
+    .strict(),
+);
 export type CommandSupervisionReceipt = z.infer<typeof CommandSupervisionReceipt>;
 
-export const ModalRouterProviderCommand = z
-  .object({
-    kind: z.literal("modal-router-v1"),
-    sandboxId: z.string().min(1).max(200),
-    taskId: z.string().min(1).max(200),
-    execId: z.string().uuid(),
-    pty: z.boolean().optional(),
-    supervision: CommandSupervisionDescriptor.optional(),
-    streams: z.object({ stdout: ModalByteCursor, stderr: ModalByteCursor }).strict(),
-  })
-  .strict();
+export const ModalRouterProviderCommand = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      kind: z.literal("modal-router-v1"),
+      sandboxId: z.string().min(1).max(200),
+      taskId: z.string().min(1).max(200),
+      execId: primitives.uuid,
+      pty: primitives.optionalBoolean,
+      supervision: CommandSupervisionDescriptor.optional(),
+      streams: z.object({ stdout: ModalByteCursor, stderr: ModalByteCursor }).strict(),
+    })
+    .strict(),
+);
 export type ModalRouterProviderCommand = z.infer<typeof ModalRouterProviderCommand>;
 
-/** Legacy locators are read-only compatibility for already launched commands;
- * new starts use authenticated task-router byte offsets, never batch indices. */
-export const SandboxProviderCommand = z.discriminatedUnion("kind", [
-  ModalLegacyProviderCommand,
-  ModalRouterProviderCommand,
-]);
+/** Provider-owned execution identity and acknowledged byte-offset cursors.
+ * These values are retained by the control plane, never recovered from
+ * sandbox files. */
+export const SandboxProviderCommand = ModalRouterProviderCommand;
 export type SandboxProviderCommand = z.infer<typeof SandboxProviderCommand>;

package/src/sandbox-recovery.ts

@@ -1,91 +1,174 @@
+import * as primitives from "./primitives";
+import { defineSchema } from "./define-schema";
 import { z } from "zod";
 
-/** Public, content-free selection. Never include native provider bindings. */
-export const SandboxRecoverySelection = z
-  .object({
-    version: z.literal(1),
-    sessionId: z.string().uuid(),
-    sandboxGroupId: z.string().uuid(),
-    leaseId: z.string().uuid(),
-    routeEpoch: z.number().int().nonnegative(),
-    authorityEpoch: z.number().int().positive(),
-    leaseEpoch: z.number().int().nonnegative(),
-    workspaceGeneration: z.number().int().nonnegative(),
-    archiveGeneration: z.number().int().nonnegative(),
-    artifactId: z.string().uuid(),
-    revision: z.string().min(1).max(512),
-    capturedAt: z.string().datetime(),
-  })
-  .strict();
+const checkpointSelectionFields = () => ({
+  version: z.literal(1),
+  sessionId: primitives.uuid,
+  sandboxGroupId: primitives.uuid,
+  leaseId: primitives.uuid,
+  routeEpoch: primitives.nonnegativeInteger,
+  authorityEpoch: primitives.positiveInteger,
+  leaseEpoch: primitives.nonnegativeInteger,
+  workspaceGeneration: primitives.nonnegativeInteger,
+  archiveGeneration: primitives.nonnegativeInteger,
+  revision: z.string().min(1).max(512),
+  capturedAt: primitives.dateTime,
+});
+
+/** Public, content-free selection of a registered native checkpoint, offered
+ * for human consent. Never include native provider bindings. */
+export const SandboxRecoverySelection = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      ...checkpointSelectionFields(),
+      artifactId: primitives.uuid,
+    })
+    .strict(),
+);
 export type SandboxRecoverySelection = z.infer<typeof SandboxRecoverySelection>;
 
-export const SandboxRecoveryProjection = z
-  .object({
-    version: z.literal(1),
-    status: z.enum([
-      "unsupported",
-      "blocked",
-      "eligible",
-      "consent_accepted",
-      "restoring",
-      "restored",
-    ]),
-    reason: z.string().max(128).nullable(),
-    checkpoint: SandboxRecoverySelection.nullable(),
-    operationId: z.string().uuid().nullable(),
-    /** Retry may elect a system-selected verified checkpoint; no consent POST. */
-    automaticAvailable: z.boolean().optional(),
-    /** What an automatic Retry will do: restore `checkpoint`, or continue on a
-     * new empty workspace because no usable checkpoint survived the loss. */
-    automaticLane: z.enum(["checkpoint", "fresh_workspace"]).optional(),
-    /** For a timed recovery wait: the earliest time a Retry or a new message
-     * can let OpenGeni decide again. Nothing proceeds by itself before then. */
-    availableAt: z.string().datetime().optional(),
-  })
-  .strict();
+/** The checkpoint automatic recovery restores, native or portable. `artifactId`
+ * is the registered native checkpoint (Modal), or null for a portable archive,
+ * whose bytes are verified against `revision` instead. Only human consent uses
+ * {@link SandboxRecoverySelection}, which always names a native checkpoint. */
+export const SandboxCheckpointSelection = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      ...checkpointSelectionFields(),
+      artifactId: primitives.nullableUuid,
+    })
+    .strict(),
+);
+export type SandboxCheckpointSelection = z.infer<typeof SandboxCheckpointSelection>;
+
+/** Exact failed/current workspace selection; portable archives need no native
+ * checkpoint artifact. Contains no object keys or provider credentials. */
+export const SandboxRecoveryTarget = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      sessionId: primitives.uuid,
+      sandboxGroupId: primitives.uuid,
+      leaseId: primitives.uuid,
+      routeEpoch: primitives.nonnegativeInteger,
+      authorityEpoch: primitives.positiveInteger,
+      leaseEpoch: primitives.nonnegativeInteger,
+      workspaceGeneration: primitives.nonnegativeInteger,
+      archiveGeneration: z.number().int().nonnegative().nullable(),
+      revision: z.string().min(1).max(512).nullable(),
+      restoreStatus: z.string().min(1).max(64),
+      restoreCompletedAt: z.string().datetime().nullable(),
+    })
+    .strict(),
+);
+export type SandboxRecoveryTarget = z.infer<typeof SandboxRecoveryTarget>;
+
+export const SandboxRecoveryProjection = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      version: z.literal(1),
+      status: z.enum([
+        "unsupported",
+        "blocked",
+        "eligible",
+        "consent_accepted",
+        "restoring",
+        "restored",
+      ]),
+      reason: z.string().max(128).nullable(),
+      /** The registered native checkpoint a person can consent to restore, and
+       * for an automatic Retry its checkpoint when that one is native. */
+      checkpoint: SandboxRecoverySelection.nullable(),
+      operationId: primitives.nullableUuid,
+      target: SandboxRecoveryTarget.optional(),
+      retryAvailable: primitives.optionalBoolean,
+      freshWorkspaceAvailable: primitives.optionalBoolean,
+      groupSessionCount: z.number().int().positive().optional(),
+      /** Retry may elect a system-selected verified checkpoint; no consent POST. */
+      automaticAvailable: primitives.optionalBoolean,
+      /** What an automatic Retry will do: restore `automaticCheckpoint`, or
+       * continue on a new empty workspace because no usable checkpoint survived
+       * the loss. */
+      automaticLane: z.enum(["checkpoint", "fresh_workspace"]).optional(),
+      /** The checkpoint an automatic Retry restores (lane `checkpoint`), native
+       * or portable. Older readers use `checkpoint`, which is set only when it
+       * is native. */
+      automaticCheckpoint: SandboxCheckpointSelection.optional(),
+      /** For a timed recovery wait: the earliest time a Retry or a new message
+       * can let Opengeni decide again. Nothing proceeds by itself before then. */
+      availableAt: z.string().datetime().optional(),
+    })
+    .strict(),
+);
 export type SandboxRecoveryProjection = z.infer<typeof SandboxRecoveryProjection>;
 
 /** Why a definitively lost managed sandbox continues on an empty workspace. */
-export const SandboxFreshWorkspaceReason = z.enum([
-  "archive_unavailable",
-  "archive_unverified",
-  "checkpoint_unrestorable",
-  "checkpoint_restore_failed",
-]);
+export const SandboxFreshWorkspaceReason = /* @__PURE__ */ defineSchema(() =>
+  z.enum([
+    "archive_unavailable",
+    "archive_unverified",
+    "checkpoint_unrestorable",
+    "checkpoint_restore_failed",
+    "restore_abandoned",
+  ]),
+);
 export type SandboxFreshWorkspaceReason = z.infer<typeof SandboxFreshWorkspaceReason>;
 
 /** Durable, content-free fresh-workspace decision for one group member. */
-export const SandboxFreshWorkspaceRecovery = z
-  .object({
-    version: z.literal(1),
-    sessionId: z.string().uuid(),
-    sandboxGroupId: z.string().uuid(),
-    leaseId: z.string().uuid(),
-    leaseEpoch: z.number().int().nonnegative(),
-    workspaceGeneration: z.number().int().nonnegative(),
-    archiveGeneration: z.number().int().nonnegative().nullable(),
-    lostAt: z.string().datetime(),
-    reason: SandboxFreshWorkspaceReason,
-  })
-  .strict();
+export const SandboxFreshWorkspaceRecovery = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      version: z.literal(1),
+      sessionId: primitives.uuid,
+      sandboxGroupId: primitives.uuid,
+      leaseId: primitives.uuid,
+      leaseEpoch: primitives.nonnegativeInteger,
+      workspaceGeneration: primitives.nonnegativeInteger,
+      archiveGeneration: z.number().int().nonnegative().nullable(),
+      lostAt: primitives.dateTime,
+      reason: SandboxFreshWorkspaceReason,
+    })
+    .strict(),
+);
 export type SandboxFreshWorkspaceRecovery = z.infer<typeof SandboxFreshWorkspaceRecovery>;
 
-export const SandboxRecoveryRequest = z
-  .object({
-    operationId: z.string().uuid(),
-    acceptHistoricalCheckpoint: z.literal(true),
-    selection: SandboxRecoverySelection,
-  })
-  .strict();
+export const SandboxRecoveryRequest = /* @__PURE__ */ defineSchema(() =>
+  z.union([
+    z
+      .object({
+        operationId: primitives.uuid,
+        acceptHistoricalCheckpoint: z.literal(true),
+        selection: SandboxRecoverySelection,
+      })
+      .strict(),
+    z
+      .object({
+        operationId: primitives.uuid,
+        action: z.literal("retry"),
+        target: SandboxRecoveryTarget,
+      })
+      .strict(),
+    z
+      .object({
+        operationId: primitives.uuid,
+        action: z.literal("continue_fresh"),
+        acceptEmptyWorkspace: z.literal(true),
+        target: SandboxRecoveryTarget,
+      })
+      .strict(),
+  ]),
+);
 export type SandboxRecoveryRequest = z.infer<typeof SandboxRecoveryRequest>;
 
-export const SandboxRecoveryResponse = z
-  .object({
-    outcome: z.enum(["accepted", "replayed"]),
-    operationId: z.string().uuid(),
-    recovery: SandboxRecoveryProjection,
-  })
-  .strict();
+export const SandboxRecoveryResponse = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      outcome: z.enum(["accepted", "replayed"]),
+      operationId: primitives.uuid,
+      recovery: SandboxRecoveryProjection,
+    })
+    .strict(),
+);
 export type SandboxRecoveryResponse = z.infer<typeof SandboxRecoveryResponse>;
 
 /** Re-injected from durable receipts on every attempt, not lossy transcript state. */
@@ -97,14 +180,14 @@ export function sandboxRecoveryDiscontinuity(selection: SandboxRecoverySelection
  * `shared` names the sandbox this session shares with other sessions; every
  * member of that group receives its own receipt for the same selection. */
 export function automaticSandboxRecoveryDiscontinuity(
-  selection: SandboxRecoverySelection,
+  selection: SandboxCheckpointSelection,
   scope: "session" | "shared" = "session",
 ): string {
   const subject =
     scope === "shared"
       ? "the latest verified checkpoint of the sandbox this session shares with other sessions"
       : "this session's latest verified checkpoint";
-  return `Filesystem discontinuity: after the managed sandbox was lost, OpenGeni selected ${subject}, captured at ${selection.capturedAt} (archive generation ${selection.archiveGeneration}, pre-recovery workspace generation ${selection.workspaceGeneration}). Newer filesystem changes may be unavailable; the generation gap is not a count of lost files or edits. Conversation and tool receipts remain historical evidence, not proof that their files still exist. External effects are not undone. Verify the restored filesystem before relying on previous work. Never automatically replay prior commands or operations with unknown outcomes. Checkpoint selection alone is not proof that restoration succeeded.`;
+  return `Filesystem discontinuity: after the managed sandbox was lost, Opengeni selected ${subject}, captured at ${selection.capturedAt} (archive generation ${selection.archiveGeneration}, pre-recovery workspace generation ${selection.workspaceGeneration}). Newer filesystem changes may be unavailable; the generation gap is not a count of lost files or edits. Conversation and tool receipts remain historical evidence, not proof that their files still exist. External effects are not undone. Verify the restored filesystem before relying on previous work. Never automatically replay prior commands or operations with unknown outcomes. Checkpoint selection alone is not proof that restoration succeeded.`;
 }
 
 /** Stable tail instructions for continuing on a new empty workspace. The text
@@ -112,5 +195,8 @@ export function automaticSandboxRecoveryDiscontinuity(
 export function freshWorkspaceSandboxRecoveryDiscontinuity(
   recovery: SandboxFreshWorkspaceRecovery,
 ): string {
-  return `Filesystem discontinuity: the previous managed sandbox was lost at ${recovery.lostAt} and there is no checkpoint OpenGeni can restore automatically, so OpenGeni continued this session on a new empty workspace. Files, repository clones, installed packages and running processes from before that time are not available in this workspace; do not assume they exist. Anything now in the workspace was created after that loss. Conversation and tool receipts from before it remain historical evidence, not proof that their files still exist. External effects are not undone. Verify the current filesystem before relying on previous work, and recreate what you need deliberately. Never automatically replay prior commands or operations with unknown outcomes.`;
+  if (recovery.reason === "restore_abandoned") {
+    return `Filesystem discontinuity: at ${recovery.lostAt}, an authorized person chose to continue this sandbox group on a new empty workspace after restoration failed. The previous archive is retained for recovery, but its files, repository clones, installed packages and processes are not present in this workspace. Conversation and tool receipts remain historical evidence, not proof that their files still exist. External effects are not undone. Verify the current filesystem before relying on previous work. Recreate what you need deliberately; never automatically replay commands or operations with unknown outcomes. Selection alone does not prove the new workspace is ready.`;
+  }
+  return `Filesystem discontinuity: the previous managed sandbox was lost at ${recovery.lostAt} and there is no checkpoint Opengeni can restore automatically, so Opengeni continued this session on a new empty workspace. Files, repository clones, installed packages and running processes from before that time are not available in this workspace; do not assume they exist. Anything now in the workspace was created after that loss. Conversation and tool receipts from before it remain historical evidence, not proof that their files still exist. External effects are not undone. Verify the current filesystem before relying on previous work, and recreate what you need deliberately. Never automatically replay prior commands or operations with unknown outcomes.`;
 }

package/src/scoped-knowledge.ts

@@ -1,29 +1,37 @@
+import * as primitives from "./primitives";
+import { defineSchema } from "./define-schema";
 import { z } from "zod";
 
 /** Tenant scope for normalized knowledge and source provenance. */
-export const ScopedKnowledgeScopeKind = z.enum(["organization", "workspace", "personal"]);
+export const ScopedKnowledgeScopeKind = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["organization", "workspace", "personal"]),
+);
 export type ScopedKnowledgeScopeKind = z.infer<typeof ScopedKnowledgeScopeKind>;
 
-export const ScopedKnowledgeScope = z.discriminatedUnion("kind", [
-  z.object({
-    kind: z.literal("organization"),
-    workspaceId: z.null(),
-    subjectId: z.null(),
-  }),
-  z.object({
-    kind: z.literal("workspace"),
-    workspaceId: z.string().uuid(),
-    subjectId: z.null(),
-  }),
-  z.object({
-    kind: z.literal("personal"),
-    workspaceId: z.string().uuid().nullable(),
-    subjectId: z.string().min(1).max(1024),
-  }),
-]);
+export const ScopedKnowledgeScope = /* @__PURE__ */ defineSchema(() =>
+  z.discriminatedUnion("kind", [
+    z.object({
+      kind: z.literal("organization"),
+      workspaceId: z.null(),
+      subjectId: z.null(),
+    }),
+    z.object({
+      kind: z.literal("workspace"),
+      workspaceId: primitives.uuid,
+      subjectId: z.null(),
+    }),
+    z.object({
+      kind: z.literal("personal"),
+      workspaceId: primitives.nullableUuid,
+      subjectId: z.string().min(1).max(1024),
+    }),
+  ]),
+);
 export type ScopedKnowledgeScope = z.infer<typeof ScopedKnowledgeScope>;
 
-export const ScopedKnowledgeActorKind = z.enum(["human", "service"]);
+export const ScopedKnowledgeActorKind = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["human", "service"]),
+);
 export type ScopedKnowledgeActorKind = z.infer<typeof ScopedKnowledgeActorKind>;
 
 /**
@@ -36,46 +44,57 @@ export type ScopedKnowledgeActor = {
   initiatingHumanSubjectId: string | null;
 };
 
-export const KnowledgeLifecycleState = z.enum(["active", "deleted", "revoked"]);
+export const KnowledgeLifecycleState = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["active", "deleted", "revoked"]),
+);
 export type KnowledgeLifecycleState = z.infer<typeof KnowledgeLifecycleState>;
 
-export const KnowledgeLifecycleEventType = z.enum([
-  "deleted",
-  "revoked",
-  "restored",
-  "acl_changed",
-  "sync_succeeded",
-  "sync_failed",
-  "object_version_added",
-]);
+export const KnowledgeLifecycleEventType = /* @__PURE__ */ defineSchema(() =>
+  z.enum([
+    "deleted",
+    "revoked",
+    "restored",
+    "acl_changed",
+    "sync_succeeded",
+    "sync_failed",
+    "object_version_added",
+  ]),
+);
 export type KnowledgeLifecycleEventType = z.infer<typeof KnowledgeLifecycleEventType>;
 
-export const KnowledgeSyncRunState = z.enum(["started", "succeeded", "failed"]);
+export const KnowledgeSyncRunState = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["started", "succeeded", "failed"]),
+);
 export type KnowledgeSyncRunState = z.infer<typeof KnowledgeSyncRunState>;
 
-export const KnowledgeClaimOrigin = z.enum(["explicit", "inferred"]);
+export const KnowledgeClaimOrigin = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["explicit", "inferred"]),
+);
 export type KnowledgeClaimOrigin = z.infer<typeof KnowledgeClaimOrigin>;
 
-export const KnowledgeClaimRelationType = z.enum(["supersedes", "conflicts_with"]);
+export const KnowledgeClaimRelationType = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["supersedes", "conflicts_with"]),
+);
 export type KnowledgeClaimRelationType = z.infer<typeof KnowledgeClaimRelationType>;
 
-export const KnowledgeClaimEvidencePolarity = z.enum(["supports", "contradicts"]);
+export const KnowledgeClaimEvidencePolarity = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["supports", "contradicts"]),
+);
 export type KnowledgeClaimEvidencePolarity = z.infer<typeof KnowledgeClaimEvidencePolarity>;
 
-export const KnowledgeClaimReviewState = z.enum(["proposed", "approved", "rejected", "revoked"]);
+export const KnowledgeClaimReviewState = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["proposed", "approved", "rejected", "revoked"]),
+);
 export type KnowledgeClaimReviewState = z.infer<typeof KnowledgeClaimReviewState>;
 
-export const KnowledgeFactObjectKind = z.enum([
-  "entity",
-  "text",
-  "number",
-  "boolean",
-  "json",
-  "timestamp",
-]);
+export const KnowledgeFactObjectKind = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["entity", "text", "number", "boolean", "json", "timestamp"]),
+);
 export type KnowledgeFactObjectKind = z.infer<typeof KnowledgeFactObjectKind>;
 
-export const KnowledgeChangeProposalTargetKind = z.enum(["instruction_policy", "preference"]);
+export const KnowledgeChangeProposalTargetKind = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["instruction_policy", "preference"]),
+);
 export type KnowledgeChangeProposalTargetKind = z.infer<typeof KnowledgeChangeProposalTargetKind>;
 
 export type KnowledgeProviderRecord = {