@chalksurf/cli 0.2.4 → 0.3.0

package/dist/bin/chalksurf.js

@@ -7,20 +7,33 @@ import { hideBin } from "yargs/helpers";
 import yargs from "yargs/yargs";
 
 // src/lib/api-client.ts
+var ApiClientError = class extends Error {
+  agentErrorCode;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "ApiClientError";
+    this.agentErrorCode = options.agentErrorCode;
+  }
+};
 var normalizeBaseUrl = (baseUrl) => {
   return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
 };
 var getErrorMessage = (payload, status) => {
   return payload?.error?.message ?? `API request failed with status ${status}`;
 };
+var getAgentErrorCode = (payload) => payload?.error?.data?.agentErrorCode;
 var getResponseData = async ({ response, batched }) => {
   const body = await response.json();
   const payload = batched ? body[0] : body;
   if (!response.ok) {
-    throw new Error(getErrorMessage(payload, response.status));
+    throw new ApiClientError(getErrorMessage(payload, response.status), {
+      agentErrorCode: getAgentErrorCode(payload)
+    });
   }
   if (payload?.error) {
-    throw new Error(payload.error.message);
+    throw new ApiClientError(payload.error.message, {
+      agentErrorCode: getAgentErrorCode(payload)
+    });
   }
   if (!payload?.result) {
     throw new Error("API response is missing a result payload");
@@ -101,30 +114,66 @@ var createApiClient = ({
     agentGetExerciseUsage: async (id) => {
       return await query("agentGetExerciseUsage", { id });
     },
+    agentListExerciseLabels: async () => {
+      return await query("agentListExerciseLabels", {});
+    },
     agentCopyExercise: async (id) => {
       return await mutation("agentCopyExercise", { id });
     },
+    agentDeleteExercise: async (input) => {
+      return await mutation("agentDeleteExercise", input);
+    },
+    agentCreateExercise: async (input) => {
+      return await mutation("agentCreateExercise", input);
+    },
     agentUpdateExercise: async (input) => {
       return await mutation("agentUpdateExercise", input);
     },
+    agentSetExerciseVisibility: async (input) => {
+      return await mutation("agentSetExerciseVisibility", input);
+    },
     agentGetSheet: async (id) => {
       return await query("agentGetSheet", { id });
     },
+    agentListSheetVersions: async (id) => {
+      return await query("agentListSheetVersions", { id });
+    },
+    agentGetSheetVersion: async (exerciseSheetId, versionId) => {
+      return await query("agentGetSheetVersion", { exerciseSheetId, versionId });
+    },
     agentGetSheetIssues: async (id) => {
       return await query("agentGetSheetIssues", { id });
     },
     agentCopySheet: async (input) => {
       return await mutation("agentCopySheet", input);
     },
+    agentDeleteSheet: async (input) => {
+      return await mutation("agentDeleteSheet", input);
+    },
+    agentCreateSheet: async (input) => {
+      return await mutation("agentCreateSheet", input);
+    },
     agentUpdateSheet: async (input) => {
       return await mutation("agentUpdateSheet", input);
     },
+    agentSetSheetVisibility: async (input) => {
+      return await mutation("agentSetSheetVisibility", input);
+    },
     agentAppendExercisesToSheet: async (input) => {
       return await mutation("agentAppendExercisesToSheet", input);
     },
     agentListFolders: async () => {
       return await query("agentListFolders", {});
     },
+    agentSendUserFeedback: async (input) => {
+      return await mutation("agentSendUserFeedback", input);
+    },
+    agentSendAgentFeedback: async (input) => {
+      return await mutation("agentSendAgentFeedback", input);
+    },
+    agentDeleteFolder: async (input) => {
+      return await mutation("agentDeleteFolder", input);
+    },
     agentCreateFolder: async (input) => {
       return await mutation("agentCreateFolder", input);
     },
@@ -157,14 +206,16 @@ var createSerializableCliError = ({
   code,
   exitCode,
   message,
-  retryable
+  retryable,
+  agentErrorCode
 }) => {
   const resolvedCode = code ?? getCliErrorCode(exitCode);
   return {
     code: resolvedCode,
     exitCode,
     message,
-    retryable: retryable ?? isRetryableCliErrorCode(resolvedCode)
+    retryable: retryable ?? isRetryableCliErrorCode(resolvedCode),
+    ...agentErrorCode ? { agentErrorCode } : {}
   };
 };
 var CliCommandError = class extends Error {
@@ -172,6 +223,7 @@ var CliCommandError = class extends Error {
   exitCode;
   retryable;
   shouldReport;
+  agentErrorCode;
   constructor(message, exitCode, shouldReport = true, options = {}) {
     super(message);
     this.name = "CliCommandError";
@@ -179,6 +231,7 @@ var CliCommandError = class extends Error {
     this.exitCode = exitCode;
     this.retryable = options.retryable ?? isRetryableCliErrorCode(this.code);
     this.shouldReport = shouldReport;
+    this.agentErrorCode = options.agentErrorCode;
   }
 };
 var serializeCliError = (error) => {
@@ -186,7 +239,8 @@ var serializeCliError = (error) => {
     code: error.code,
     exitCode: error.exitCode,
     message: error.message,
-    retryable: error.retryable
+    retryable: error.retryable,
+    agentErrorCode: error.agentErrorCode
   });
 };
 
@@ -587,10 +641,15 @@ var normalizeOptionalString2 = (value) => {
 };
 var mapApiErrorToCliError = (error) => {
   const message = error instanceof Error ? error.message : "Unknown API error";
+  const agentErrorCode = error instanceof ApiClientError ? error.agentErrorCode : void 0;
   if (message.includes("UNAUTHORIZED")) {
-    return new CliCommandError("Authentication failed. The CLI token is invalid or revoked.", 3);
+    return new CliCommandError("Authentication failed. The CLI token is invalid or revoked.", 3, true, {
+      agentErrorCode
+    });
   }
-  return new CliCommandError(`API request failed: ${message}`, 5);
+  return new CliCommandError(`API request failed: ${message}`, 5, true, {
+    agentErrorCode
+  });
 };
 var requireResolvedBaseUrl = ({
   flagValue,
@@ -867,7 +926,461 @@ ${formatOrganizationSummary(result.organization)}`,
 };
 
 // src/commands/exercise.ts
-import { z as z8 } from "zod";
+import { z as z11 } from "zod";
+
+// ../shared/src/labels.json
+var labels_default = [
+  {
+    id: "algebra",
+    name: "algebra",
+    children: [
+      {
+        id: "algebra.identities",
+        name: "identities"
+      },
+      {
+        id: "algebra.inequalities",
+        name: "inequalities"
+      },
+      {
+        id: "algebra.equations",
+        name: "equations",
+        children: [
+          {
+            id: "algebra.equations.linear_equation",
+            name: "linear equation"
+          },
+          {
+            id: "algebra.equations.quadratic_equation",
+            name: "quadratic equation"
+          },
+          {
+            id: "algebra.equations.higher_order_equation",
+            name: "higher order equation"
+          },
+          {
+            id: "algebra.equations.absolute_value_equation",
+            name: "absolute value equation"
+          },
+          {
+            id: "algebra.equations.diophantine_equation",
+            name: "Diophantine equation"
+          },
+          {
+            id: "algebra.equations.square_root_equation",
+            name: "square root equation"
+          },
+          {
+            id: "algebra.equations.exponential_logarithmic_equation",
+            name: "exponential, logarithmic equation"
+          },
+          {
+            id: "algebra.equations.trigonometric_equation",
+            name: "trigonometric equation"
+          },
+          {
+            id: "algebra.equations.parametric_equation",
+            name: "parametric equation"
+          },
+          {
+            id: "algebra.equations.equation_systems",
+            name: "equation systems"
+          }
+        ]
+      },
+      {
+        id: "algebra.means",
+        name: "means"
+      }
+    ]
+  },
+  {
+    id: "arithmetic",
+    name: "arithmetic",
+    children: [
+      {
+        id: "arithmetic.counting",
+        name: "counting"
+      },
+      {
+        id: "arithmetic.fractions",
+        name: "fractions"
+      },
+      {
+        id: "arithmetic.proportionality",
+        name: "proportionality"
+      },
+      {
+        id: "arithmetic.digits",
+        name: "digits"
+      },
+      {
+        id: "arithmetic.powers",
+        name: "powers"
+      },
+      {
+        id: "arithmetic.percentage",
+        name: "percentage"
+      },
+      {
+        id: "arithmetic.square_roots",
+        name: "(square) roots"
+      },
+      {
+        id: "arithmetic.numeral_systems",
+        name: "numeral systems"
+      },
+      {
+        id: "arithmetic.units_of_measurement",
+        name: "units of measurement"
+      }
+    ]
+  },
+  {
+    id: "number_theory",
+    name: "number theory",
+    children: [
+      {
+        id: "number_theory.divisibility",
+        name: "divisibility"
+      },
+      {
+        id: "number_theory.prime_factorization",
+        name: "prime factorization"
+      },
+      {
+        id: "number_theory.primes_not_factorization",
+        name: "primes (not factorization)"
+      },
+      {
+        id: "number_theory.digits",
+        name: "digits"
+      },
+      {
+        id: "number_theory.modular_arithmetic",
+        name: "modular arithmetic"
+      }
+    ]
+  },
+  {
+    id: "analysis_functions",
+    name: "analysis / functions",
+    children: [
+      {
+        id: "analysis_functions.graph_of_a_function",
+        name: "graph of a function"
+      },
+      {
+        id: "analysis_functions.polynomials",
+        name: "polynomials"
+      },
+      {
+        id: "analysis_functions.monotonicity_of_function",
+        name: "monotonicity of function"
+      },
+      {
+        id: "analysis_functions.minimum_maximum_of_function",
+        name: "minimum, maximum of function"
+      },
+      {
+        id: "analysis_functions.zero_point_of_function",
+        name: "zero point of function"
+      },
+      {
+        id: "analysis_functions.derivatives",
+        name: "derivatives"
+      },
+      {
+        id: "analysis_functions.integration",
+        name: "integration"
+      },
+      {
+        id: "analysis_functions.limit_of_function",
+        name: "limit of function"
+      }
+    ]
+  },
+  {
+    id: "sequences",
+    name: "sequences",
+    children: [
+      {
+        id: "sequences.arithmetic_progression",
+        name: "arithmetic progression"
+      },
+      {
+        id: "sequences.geometric_progression",
+        name: "geometric progression"
+      },
+      {
+        id: "sequences.recursion",
+        name: "recursion"
+      },
+      {
+        id: "sequences.periodic",
+        name: "periodic"
+      },
+      {
+        id: "sequences.fibonacci",
+        name: "Fibonacci"
+      },
+      {
+        id: "sequences.monotonicity_boundedness",
+        name: "monotonicity, boundedness"
+      },
+      {
+        id: "sequences.limit",
+        name: "limit"
+      }
+    ]
+  },
+  {
+    id: "geometry",
+    name: "geometry",
+    children: [
+      {
+        id: "geometry.3d_geometry",
+        name: "3D geometry",
+        children: [
+          {
+            id: "geometry.3d_geometry.surface_area_volume",
+            name: "surface area, volume"
+          },
+          {
+            id: "geometry.3d_geometry.polyhedron_net",
+            name: "polyhedron net"
+          },
+          {
+            id: "geometry.3d_geometry.platonic_solids",
+            name: "Platonic solids"
+          },
+          {
+            id: "geometry.3d_geometry.cylinder",
+            name: "cylinder"
+          },
+          {
+            id: "geometry.3d_geometry.prism",
+            name: "prism"
+          },
+          {
+            id: "geometry.3d_geometry.pyramid",
+            name: "pyramid"
+          },
+          {
+            id: "geometry.3d_geometry.cone",
+            name: "cone"
+          },
+          {
+            id: "geometry.3d_geometry.3d_transformations",
+            name: "3D transformations"
+          }
+        ]
+      },
+      {
+        id: "geometry.vectors",
+        name: "vectors"
+      },
+      {
+        id: "geometry.coordinate_geometry",
+        name: "coordinate geometry"
+      },
+      {
+        id: "geometry.pythagorean_theorem",
+        name: "Pythagorean theorem"
+      },
+      {
+        id: "geometry.thales_theorem",
+        name: "Thales theorem"
+      },
+      {
+        id: "geometry.circumference_area",
+        name: "circumference, area"
+      },
+      {
+        id: "geometry.triangle",
+        name: "triangle"
+      },
+      {
+        id: "geometry.rectangle",
+        name: "rectangle"
+      },
+      {
+        id: "geometry.polygon",
+        name: "polygon"
+      },
+      {
+        id: "geometry.regular_polygon",
+        name: "regular polygon"
+      },
+      {
+        id: "geometry.circle",
+        name: "circle"
+      },
+      {
+        id: "geometry.conic_section",
+        name: "conic section"
+      },
+      {
+        id: "geometry.angles",
+        name: "angles"
+      },
+      {
+        id: "geometry.trigonometry",
+        name: "trigonometry"
+      },
+      {
+        id: "geometry.transformations",
+        name: "transformations"
+      },
+      {
+        id: "geometry.symmetry",
+        name: "symmetry"
+      },
+      {
+        id: "geometry.similarity",
+        name: "similarity"
+      }
+    ]
+  },
+  {
+    id: "probability_and_statistics",
+    name: "probability and statistics",
+    children: [
+      {
+        id: "probability_and_statistics.combinatorial_probability",
+        name: "combinatorial probability"
+      },
+      {
+        id: "probability_and_statistics.geometric_probability",
+        name: "geometric probability"
+      },
+      {
+        id: "probability_and_statistics.bayes_theorem",
+        name: "Bayes theorem"
+      },
+      {
+        id: "probability_and_statistics.independence",
+        name: "independence"
+      },
+      {
+        id: "probability_and_statistics.mean_variance",
+        name: "mean, variance"
+      },
+      {
+        id: "probability_and_statistics.statistics",
+        name: "statistics"
+      }
+    ]
+  },
+  {
+    id: "combinatorics",
+    name: "combinatorics",
+    children: [
+      {
+        id: "combinatorics.combination_variation",
+        name: "combination, variation"
+      },
+      {
+        id: "combinatorics.permutation",
+        name: "permutation"
+      },
+      {
+        id: "combinatorics.inclusion_exclusion",
+        name: "inclusion exclusion"
+      },
+      {
+        id: "combinatorics.geometric_combinatorics",
+        name: "geometric combinatorics"
+      }
+    ]
+  },
+  {
+    id: "graphs",
+    name: "graphs",
+    children: [
+      {
+        id: "graphs.plane_graphs",
+        name: "plane graphs"
+      },
+      {
+        id: "graphs.paths_walks",
+        name: "paths, walks"
+      },
+      {
+        id: "graphs.degrees",
+        name: "degrees"
+      },
+      {
+        id: "graphs.subgraph",
+        name: "subgraph"
+      },
+      {
+        id: "graphs.bipartite_graph",
+        name: "bipartite graph"
+      },
+      {
+        id: "graphs.oriented_graph",
+        name: "oriented graph"
+      }
+    ]
+  },
+  {
+    id: "set_theory",
+    name: "set theory",
+    children: [
+      {
+        id: "set_theory.set_arithmetics",
+        name: "set arithmetics"
+      },
+      {
+        id: "set_theory.inclusion_exclusion",
+        name: "inclusion exclusion"
+      },
+      {
+        id: "set_theory.de_morgan_identities",
+        name: "de Morgan identities"
+      },
+      {
+        id: "set_theory.intervals",
+        name: "intervals"
+      },
+      {
+        id: "set_theory.number_sets",
+        name: "number sets"
+      }
+    ]
+  },
+  {
+    id: "logic",
+    name: "logic",
+    children: [
+      {
+        id: "logic.logic_arithmetics",
+        name: "logic arithmetics"
+      },
+      {
+        id: "logic.true_false",
+        name: "true false"
+      },
+      {
+        id: "logic.recursive_logic",
+        name: "recursive logic"
+      },
+      {
+        id: "logic.winning_strategy",
+        name: "winning strategy"
+      },
+      {
+        id: "logic.tiling",
+        name: "tiling"
+      },
+      {
+        id: "logic.algorithm",
+        name: "algorithm"
+      }
+    ]
+  }
+];
 
 // ../shared/src/agent-tools/index.ts
 import { z } from "zod";
@@ -910,8 +1423,38 @@ var Constants = {
   },
   public: {
     Enums: {
-      event_type: ["feedback_sent", "feedback_abandoned", "error_report"],
+      agent_audit_actor_kind: ["cli_token", "mcp_oauth"],
+      agent_audit_operation: [
+        "send_user_feedback",
+        "send_agent_feedback",
+        "copy_exercise",
+        "copy_sheet",
+        "update_exercise",
+        "update_sheet",
+        "append_exercises_to_sheet",
+        "create_folder",
+        "rename_folder",
+        "delete_exercise",
+        "delete_sheet",
+        "delete_folder",
+        "create_sheet",
+        "create_exercise",
+        "set_exercise_visibility",
+        "set_sheet_visibility",
+        "import_exercise_started",
+        "import_exercise_completed",
+        "import_exercise_solution_started",
+        "import_exercise_solution_completed",
+        "import_sheet_started",
+        "import_sheet_completed",
+        "import_sheet_solutions_started",
+        "import_sheet_solutions_completed"
+      ],
+      agent_audit_outcome: ["started", "success", "failed", "denied"],
+      agent_audit_resource_type: ["exercise", "sheet", "folder", "job", "event"],
+      event_type: ["feedback_sent", "feedback_abandoned", "error_report", "user_feedback_sent", "agent_feedback_sent"],
       exercise_sheet_translation_status: ["ready", "preparing", "failed"],
+      exercise_sheet_version_type: ["backfill", "create", "manual_edit", "copy", "sheet_import", "revert"],
       exercise_status: ["verified", "unverified", "invalid"],
       exercise_subject: ["math", "physics", "chemistry", "informatics"],
       exercise_version_type: [
@@ -966,12 +1509,23 @@ var latexValidationIssueCodes = [
 // ../shared/src/types/types.ts
 var exerciseStatusOptions = Constants.public.Enums.exercise_status;
 var exerciseVersionTypes = Constants.public.Enums.exercise_version_type;
+var agentAuditActorKinds = Constants.public.Enums.agent_audit_actor_kind;
+var agentAuditOutcomes = Constants.public.Enums.agent_audit_outcome;
+var agentAuditOperations = Constants.public.Enums.agent_audit_operation;
+var agentAuditResourceTypes = Constants.public.Enums.agent_audit_resource_type;
 var exerciseSheetTranslationStatuses = Constants.public.Enums.exercise_sheet_translation_status;
+var exerciseSheetVersionTypes = Constants.public.Enums.exercise_sheet_version_type;
 var mcpOAuthGrantPermissions = ["read", "write"];
 var jobTypes = Constants.public.Enums.job_type;
 var userJobStatuses = Constants.public.Enums.user_job_status;
 var eventTypes = Constants.public.Enums.event_type;
 var exerciseSubjects = Constants.public.Enums.exercise_subject;
+var exportTemplateIds = [
+  "exercises",
+  "exercises-with-workspace",
+  "exercises-with-solutions",
+  "exercises-with-answers"
+];
 var organizationTypes = Constants.public.Enums.organization_type;
 var organizationMemberRoles = Constants.public.Enums.organization_member_role;
 var organizationInvitationStatuses = Constants.public.Enums.organization_invitation_status;
@@ -989,6 +1543,147 @@ var exerciseSheetTranslationFields = [
   "description"
 ];
 
+// ../shared/src/agent-tools/operations.ts
+var agentWriteOperationRegistry = {
+  send_user_feedback: {
+    agentToolName: "send_user_feedback",
+    receiptOperation: null,
+    resourceType: "event",
+    sync: true
+  },
+  send_agent_feedback: {
+    agentToolName: "send_agent_feedback",
+    receiptOperation: null,
+    resourceType: "event",
+    sync: true
+  },
+  copy_exercise: {
+    agentToolName: "copy_exercise",
+    receiptOperation: "copy_exercise",
+    resourceType: "exercise",
+    sync: true
+  },
+  copy_sheet: {
+    agentToolName: "copy_sheet",
+    receiptOperation: "copy_sheet",
+    resourceType: "sheet",
+    sync: true
+  },
+  update_exercise: {
+    agentToolName: "update_exercise",
+    receiptOperation: "update_exercise",
+    resourceType: "exercise",
+    sync: true
+  },
+  update_sheet: {
+    agentToolName: "update_sheet",
+    receiptOperation: "update_sheet",
+    resourceType: "sheet",
+    sync: true
+  },
+  append_exercises_to_sheet: {
+    agentToolName: "append_exercises_to_sheet",
+    receiptOperation: "append_exercises_to_sheet",
+    resourceType: "sheet",
+    sync: true
+  },
+  create_folder: {
+    agentToolName: "create_folder",
+    receiptOperation: "create_folder",
+    resourceType: "folder",
+    sync: true
+  },
+  rename_folder: {
+    agentToolName: "rename_folder",
+    receiptOperation: "rename_folder",
+    resourceType: "folder",
+    sync: true
+  },
+  delete_exercise: {
+    agentToolName: "delete_exercise",
+    receiptOperation: "delete_exercise",
+    resourceType: "exercise",
+    sync: true
+  },
+  delete_sheet: {
+    agentToolName: "delete_sheet",
+    receiptOperation: "delete_sheet",
+    resourceType: "sheet",
+    sync: true
+  },
+  delete_folder: {
+    agentToolName: "delete_folder",
+    receiptOperation: "delete_folder",
+    resourceType: "folder",
+    sync: true
+  },
+  create_sheet: {
+    agentToolName: "create_sheet",
+    receiptOperation: "create_sheet",
+    resourceType: "sheet",
+    sync: true
+  },
+  create_exercise: {
+    agentToolName: "create_exercise",
+    receiptOperation: "create_exercise",
+    resourceType: "exercise",
+    sync: true
+  },
+  set_exercise_visibility: {
+    agentToolName: "set_exercise_visibility",
+    receiptOperation: "set_exercise_visibility",
+    resourceType: "exercise",
+    sync: true
+  },
+  set_sheet_visibility: {
+    agentToolName: "set_sheet_visibility",
+    receiptOperation: "set_sheet_visibility",
+    resourceType: "sheet",
+    sync: true
+  },
+  import_exercise_started: {
+    receiptOperation: null,
+    resourceType: "job",
+    sync: false
+  },
+  import_exercise_completed: {
+    receiptOperation: null,
+    resourceType: "exercise",
+    sync: false
+  },
+  import_exercise_solution_started: {
+    receiptOperation: null,
+    resourceType: "job",
+    sync: false
+  },
+  import_exercise_solution_completed: {
+    receiptOperation: null,
+    resourceType: "exercise",
+    sync: false
+  },
+  import_sheet_started: {
+    receiptOperation: null,
+    resourceType: "job",
+    sync: false
+  },
+  import_sheet_completed: {
+    receiptOperation: null,
+    resourceType: "sheet",
+    sync: false
+  },
+  import_sheet_solutions_started: {
+    receiptOperation: null,
+    resourceType: "job",
+    sync: false
+  },
+  import_sheet_solutions_completed: {
+    receiptOperation: null,
+    resourceType: "sheet",
+    sync: false
+  }
+};
+var agentWriteReceiptOperations = Object.values(agentWriteOperationRegistry).map((operation) => operation.receiptOperation).filter((operation) => Boolean(operation));
+
 // ../shared/src/agent-tools/index.ts
 var strictObject = (shape) => z.object(shape).strict();
 var uuidSchema = z.uuid();
@@ -998,6 +1693,21 @@ var optionalNullableStringSchema = z.string().trim().min(1).nullable().optional(
 var metadataSchema = z.unknown().nullable();
 var patchNullableStringSchema = z.string().nullable().optional();
 var expectedUpdatedAtSchema = z.string().trim().min(1);
+var feedbackContextSchema = z.record(z.string(), z.unknown()).optional();
+var feedbackMessageSchema = z.string().trim().min(1).max(5e3);
+var agentErrorCodes = [
+  "precondition_failed",
+  "confirmation_required",
+  "resource_in_use",
+  "feature_disabled",
+  "invalid_label",
+  "forbidden",
+  "not_found",
+  "validation_failed",
+  "unauthorized"
+];
+var agentErrorCodeSchema = z.enum(agentErrorCodes);
+var agentWriteReceiptOperationSchema = z.enum(agentWriteReceiptOperations);
 var exerciseTranslationFieldNames = [
   "exercise_text",
   "description",
@@ -1069,6 +1779,37 @@ var sheetTranslationSchema = strictObject({
 var sheetTranslationStatusSchema = strictObject({
   status: z.enum(exerciseSheetTranslationStatuses)
 });
+var sheetVersionTranslationSchema = strictObject({
+  name: z.string(),
+  title: z.string().nullable(),
+  description: z.string().nullable()
+});
+var sheetVersionExerciseSchema = strictObject({
+  exerciseId: uuidSchema,
+  orderIndex: z.number().int().min(1),
+  scorePoints: z.number().nullable()
+});
+var sheetVersionSnapshotSchema = strictObject({
+  subject: z.enum(exerciseSubjects),
+  private_notes: z.string().nullable(),
+  scoring_enabled: z.boolean(),
+  translations: z.record(z.string(), sheetVersionTranslationSchema),
+  exercises: z.array(sheetVersionExerciseSchema)
+});
+var sheetVersionListItemSchema = strictObject({
+  id: uuidSchema,
+  exerciseSheetId: uuidSchema,
+  versionNumber: z.number().int().positive(),
+  createdAt: dateStringSchema,
+  createdByUserId: uuidSchema.nullable(),
+  createdByName: z.string().nullable(),
+  type: z.enum(exerciseSheetVersionTypes),
+  sourceVersionId: uuidSchema.nullable()
+});
+var sheetVersionDetailSchema = sheetVersionListItemSchema.extend({
+  snapshot: sheetVersionSnapshotSchema,
+  exercises: z.array(exerciseSummarySchema)
+});
 var sheetDetailsSchema = strictObject({
   id: uuidSchema,
   created_at: dateStringSchema,
@@ -1094,6 +1835,22 @@ var folderSchema = strictObject({
   parentId: uuidSchema.nullable(),
   updatedAt: dateStringSchema
 });
+var exerciseLabelSchema = strictObject({
+  id: z.string().trim().min(1),
+  name: z.string().trim().min(1),
+  parentId: z.string().trim().min(1).nullable(),
+  depth: z.number().int().min(0),
+  pathIds: z.array(z.string().trim().min(1)),
+  pathNames: z.array(z.string().trim().min(1)),
+  displayPath: z.string().trim().min(1),
+  childIds: z.array(z.string().trim().min(1))
+});
+var agentFeedbackEventTypeSchema = z.enum(["user_feedback_sent", "agent_feedback_sent"]);
+var feedbackReceiptSchema = strictObject({
+  eventId: uuidSchema,
+  eventType: agentFeedbackEventTypeSchema,
+  submittedAt: dateStringSchema
+});
 var exerciseUsageSheetSchema = strictObject({
   id: uuidSchema,
   name: z.string(),
@@ -1103,6 +1860,19 @@ var exerciseUsageSchema = strictObject({
   sheets: z.array(exerciseUsageSheetSchema),
   otherOrganizationSheetCount: z.number().int().min(0)
 });
+var agentWriteReceiptVersionSchema = z.discriminatedUnion("created", [
+  strictObject({
+    resourceType: z.literal("sheet"),
+    created: z.literal(true),
+    versionId: uuidSchema,
+    versionNumber: z.number().int().positive()
+  }),
+  strictObject({
+    resourceType: z.literal("sheet"),
+    created: z.literal(false),
+    reason: z.string().trim().min(1)
+  })
+]);
 var latexValidationIssueSchema = strictObject({
   code: z.enum(latexValidationIssueCodes),
   message: z.string(),
@@ -1170,6 +1940,19 @@ var getSheetAgentInputSchema = strictObject({
 var getSheetAgentOutputSchema = strictObject({
   sheet: sheetDetailsSchema
 });
+var listSheetVersionsAgentInputSchema = strictObject({
+  id: uuidSchema
+});
+var listSheetVersionsAgentOutputSchema = strictObject({
+  versions: z.array(sheetVersionListItemSchema)
+});
+var getSheetVersionAgentInputSchema = strictObject({
+  exerciseSheetId: uuidSchema,
+  versionId: uuidSchema
+});
+var getSheetVersionAgentOutputSchema = strictObject({
+  version: sheetVersionDetailSchema
+});
 var getSheetIssuesAgentInputSchema = strictObject({
   id: uuidSchema
 });
@@ -1181,6 +1964,10 @@ var listFoldersAgentInputSchema = strictObject({});
 var listFoldersAgentOutputSchema = strictObject({
   folders: z.array(folderSchema)
 });
+var listExerciseLabelsAgentInputSchema = strictObject({});
+var listExerciseLabelsAgentOutputSchema = strictObject({
+  labels: z.array(exerciseLabelSchema)
+});
 var validateLatexSnippetsAgentInputSchema = strictObject({
   snippets: z.array(
     strictObject({
@@ -1192,6 +1979,22 @@ var validateLatexSnippetsAgentInputSchema = strictObject({
 var validateLatexSnippetsAgentOutputSchema = strictObject({
   results: z.array(latexValidationResultSchema)
 });
+var sendUserFeedbackAgentInputSchema = strictObject({
+  message: feedbackMessageSchema,
+  userConsent: z.literal(true),
+  category: z.enum(["bug_report", "feature_request", "frustration", "blocked_request", "other"]).optional(),
+  context: feedbackContextSchema
+});
+var sendAgentFeedbackAgentInputSchema = strictObject({
+  message: feedbackMessageSchema,
+  category: z.enum(["api_inconsistency", "documentation_issue", "missing_capability", "unexpected_behavior", "other"]).optional(),
+  context: feedbackContextSchema
+});
+var feedbackReceiptOutputSchema = strictObject({
+  receipt: feedbackReceiptSchema
+});
+var sendUserFeedbackAgentOutputSchema = feedbackReceiptOutputSchema;
+var sendAgentFeedbackAgentOutputSchema = feedbackReceiptOutputSchema;
 var getExerciseUsageAgentInputSchema = strictObject({
   id: uuidSchema
 });
@@ -1203,7 +2006,7 @@ var agentWriteReceiptSchema = strictObject({
     type: z.enum(["exercise", "sheet", "folder"]),
     id: uuidSchema
   }),
-  operation: z.string(),
+  operation: agentWriteReceiptOperationSchema,
   changedPaths: z.array(z.string()),
   precondition: strictObject({
     expectedUpdatedAt: optionalNullableStringSchema,
@@ -1217,6 +2020,7 @@ var agentWriteReceiptSchema = strictObject({
       details: z.unknown().optional()
     })
   ),
+  version: agentWriteReceiptVersionSchema.optional(),
   details: z.unknown()
 });
 var agentWriteReceiptOutputSchema = strictObject({
@@ -1234,6 +2038,23 @@ var copySheetAgentInputSchema = strictObject({
   exerciseCopyMode: z.enum(exerciseSheetExerciseCopyModes).optional().default("keep_references")
 });
 var copySheetAgentOutputSchema = agentWriteReceiptOutputSchema;
+var deleteExerciseAgentInputSchema = strictObject({
+  id: uuidSchema,
+  expectedUpdatedAt: expectedUpdatedAtSchema,
+  confirmResourceId: uuidSchema
+});
+var deleteExerciseAgentOutputSchema = agentWriteReceiptOutputSchema;
+var deleteSheetAgentInputSchema = strictObject({
+  id: uuidSchema,
+  expectedUpdatedAt: expectedUpdatedAtSchema,
+  confirmResourceId: uuidSchema
+});
+var deleteSheetAgentOutputSchema = agentWriteReceiptOutputSchema;
+var deleteFolderAgentInputSchema = strictObject({
+  id: uuidSchema,
+  confirmResourceId: uuidSchema
+});
+var deleteFolderAgentOutputSchema = agentWriteReceiptOutputSchema;
 var createFolderAgentInputSchema = strictObject({
   name: z.string().trim().min(1),
   parentId: uuidSchema.nullable().optional()
@@ -1257,11 +2078,34 @@ var exercisePatchFigureSchema = strictObject({
   url: z.url(),
   widthInCm: z.number().positive().finite().nullable().optional()
 });
+var exerciseCreateFigureSchema = strictObject({
+  type: z.enum(exerciseFigureTypes),
+  url: z.url(),
+  widthInCm: z.number().positive().finite().optional()
+});
 var exercisePatchMetadataSchema = strictObject({
   sourceUrl: patchNullableStringSchema,
   solutionUrl: patchNullableStringSchema,
   figures: z.array(exercisePatchFigureSchema).optional()
 });
+var exerciseCreateMetadataSchema = strictObject({
+  sourceUrl: z.url().optional(),
+  solutionUrl: z.url().optional(),
+  figures: z.array(exerciseCreateFigureSchema).optional()
+});
+var createExerciseAgentInputSchema = strictObject({
+  difficulty: z.number().min(1).max(100).nullable().optional(),
+  min_age: z.number().min(0).max(100).nullable().optional(),
+  max_age: z.number().min(0).max(100).nullable().optional(),
+  source: z.string().trim().min(1).optional(),
+  metadata: exerciseCreateMetadataSchema.optional(),
+  labels: z.array(z.string()).max(30).optional(),
+  private_notes: z.string().optional(),
+  translations: z.record(z.string(), exercisePatchTranslationSchema),
+  exerciseSheetId: uuidSchema.optional(),
+  confirmMakeExercisesPublic: z.boolean().optional().default(false)
+});
+var createExerciseAgentOutputSchema = agentWriteReceiptOutputSchema;
 var updateExerciseAgentInputSchema = strictObject({
   id: uuidSchema,
   expectedUpdatedAt: expectedUpdatedAtSchema,
@@ -1295,12 +2139,43 @@ var updateSheetAgentInputSchema = strictObject({
   })
 });
 var updateSheetAgentOutputSchema = agentWriteReceiptOutputSchema;
+var createSheetScoredExerciseSchema = strictObject({
+  id: uuidSchema,
+  scorePoints: z.number().min(0).max(99999.9).refine((value) => Number.isInteger(value * 10), "Score can have at most 1 decimal place").nullable()
+});
+var createSheetAgentInputSchema = strictObject({
+  name: z.string().trim().min(1),
+  title: z.string().trim().nullable().optional(),
+  description: z.string().trim().optional(),
+  language: z.enum(translationLanguages),
+  exerciseIds: z.array(uuidSchema).max(200).optional(),
+  exercises: z.array(createSheetScoredExerciseSchema).max(200).optional(),
+  scoringEnabled: z.boolean().optional().default(false),
+  private_notes: z.string().optional()
+}).refine((data) => data.exerciseIds === void 0 || data.exercises === void 0, {
+  message: "Use exercises instead of exerciseIds when creating score values"
+});
+var createSheetAgentOutputSchema = agentWriteReceiptOutputSchema;
 var appendExercisesToSheetAgentInputSchema = strictObject({
   sheetId: uuidSchema,
   exerciseIds: z.array(uuidSchema).min(1),
   confirmMakeExercisesPublic: z.boolean().optional().default(false)
 });
 var appendExercisesToSheetAgentOutputSchema = agentWriteReceiptOutputSchema;
+var setExerciseVisibilityAgentInputSchema = strictObject({
+  id: uuidSchema,
+  expectedUpdatedAt: expectedUpdatedAtSchema,
+  isPublic: z.boolean(),
+  confirmMakePublicResourceId: uuidSchema.optional()
+});
+var setExerciseVisibilityAgentOutputSchema = agentWriteReceiptOutputSchema;
+var setSheetVisibilityAgentInputSchema = strictObject({
+  id: uuidSchema,
+  expectedUpdatedAt: expectedUpdatedAtSchema,
+  isPublic: z.boolean(),
+  confirmMakePublicResourceId: uuidSchema.optional()
+});
+var setSheetVisibilityAgentOutputSchema = agentWriteReceiptOutputSchema;
 
 // ../shared/src/agent-tools/mcp-tools.ts
 import { z as z3 } from "zod";
@@ -1516,14 +2391,30 @@ var getExerciseUsageInputSchema = getExerciseUsageAgentInputSchema.extend({
   organizationId: organizationIdSchema
 });
 var getExerciseUsageOutputSchema = getExerciseUsageAgentOutputSchema;
+var listExerciseLabelsInputSchema = listExerciseLabelsAgentInputSchema.extend({
+  organizationId: organizationIdSchema
+});
+var listExerciseLabelsOutputSchema = listExerciseLabelsAgentOutputSchema;
 var copyExerciseInputSchema = copyExerciseAgentInputSchema.extend({
   organizationId: organizationIdSchema
 });
 var copyExerciseOutputSchema = copyExerciseAgentOutputSchema;
+var deleteExerciseInputSchema = deleteExerciseAgentInputSchema.extend({
+  organizationId: organizationIdSchema
+});
+var deleteExerciseOutputSchema = deleteExerciseAgentOutputSchema;
+var createExerciseInputSchema = createExerciseAgentInputSchema.extend({
+  organizationId: organizationIdSchema
+});
+var createExerciseOutputSchema = createExerciseAgentOutputSchema;
 var updateExerciseInputSchema = updateExerciseAgentInputSchema.extend({
   organizationId: organizationIdSchema
 });
 var updateExerciseOutputSchema = updateExerciseAgentOutputSchema;
+var setExerciseVisibilityInputSchema = setExerciseVisibilityAgentInputSchema.extend({
+  organizationId: organizationIdSchema
+});
+var setExerciseVisibilityOutputSchema = setExerciseVisibilityAgentOutputSchema;
 var importExerciseInputSchema = strictObject2({
   organizationId: organizationIdSchema,
   sources: importSourcesSchema,
@@ -1562,6 +2453,14 @@ var getSheetInputSchema = getSheetAgentInputSchema.extend({
   organizationId: organizationIdSchema
 });
 var getSheetOutputSchema = getSheetAgentOutputSchema;
+var listSheetVersionsInputSchema = listSheetVersionsAgentInputSchema.extend({
+  organizationId: organizationIdSchema
+});
+var listSheetVersionsOutputSchema = listSheetVersionsAgentOutputSchema;
+var getSheetVersionInputSchema = getSheetVersionAgentInputSchema.extend({
+  organizationId: organizationIdSchema
+});
+var getSheetVersionOutputSchema = getSheetVersionAgentOutputSchema;
 var getSheetIssuesInputSchema = getSheetIssuesAgentInputSchema.extend({
   organizationId: organizationIdSchema
 });
@@ -1570,10 +2469,22 @@ var copySheetInputSchema = copySheetAgentInputSchema.extend({
   organizationId: organizationIdSchema
 });
 var copySheetOutputSchema = copySheetAgentOutputSchema;
+var deleteSheetInputSchema = deleteSheetAgentInputSchema.extend({
+  organizationId: organizationIdSchema
+});
+var deleteSheetOutputSchema = deleteSheetAgentOutputSchema;
+var createSheetInputSchema = createSheetAgentInputSchema.extend({
+  organizationId: organizationIdSchema
+});
+var createSheetOutputSchema = createSheetAgentOutputSchema;
 var updateSheetInputSchema = updateSheetAgentInputSchema.extend({
   organizationId: organizationIdSchema
 });
 var updateSheetOutputSchema = updateSheetAgentOutputSchema;
+var setSheetVisibilityInputSchema = setSheetVisibilityAgentInputSchema.extend({
+  organizationId: organizationIdSchema
+});
+var setSheetVisibilityOutputSchema = setSheetVisibilityAgentOutputSchema;
 var appendExercisesToSheetInputSchema = appendExercisesToSheetAgentInputSchema.extend({
   organizationId: organizationIdSchema
 });
@@ -1582,6 +2493,18 @@ var listFoldersInputSchema = listFoldersAgentInputSchema.extend({
   organizationId: organizationIdSchema
 });
 var listFoldersOutputSchema = listFoldersAgentOutputSchema;
+var sendUserFeedbackInputSchema = sendUserFeedbackAgentInputSchema.extend({
+  organizationId: organizationIdSchema
+});
+var sendUserFeedbackOutputSchema = sendUserFeedbackAgentOutputSchema;
+var sendAgentFeedbackInputSchema = sendAgentFeedbackAgentInputSchema.extend({
+  organizationId: organizationIdSchema
+});
+var sendAgentFeedbackOutputSchema = sendAgentFeedbackAgentOutputSchema;
+var deleteFolderInputSchema = deleteFolderAgentInputSchema.extend({
+  organizationId: organizationIdSchema
+});
+var deleteFolderOutputSchema = deleteFolderAgentOutputSchema;
 var createFolderInputSchema = createFolderAgentInputSchema.extend({
   organizationId: organizationIdSchema
 });
@@ -1693,6 +2616,16 @@ var chalksurfMcpToolCapabilities = {
     requiredPermission: "read",
     security: { type: "oauth2", scopes: [chalksurfMcpScopes.read] }
   },
+  list_exercise_labels: {
+    name: "list_exercise_labels",
+    title: "List exercise labels",
+    description: "Use this to discover canonical ChalkSurf exercise label IDs before creating or updating exercises.",
+    inputSchema: listExerciseLabelsInputSchema,
+    outputSchema: listExerciseLabelsOutputSchema,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    requiredPermission: "read",
+    security: { type: "oauth2", scopes: [chalksurfMcpScopes.read] }
+  },
   copy_exercise: {
     name: "copy_exercise",
     title: "Copy exercise",
@@ -1703,6 +2636,26 @@ var chalksurfMcpToolCapabilities = {
     requiredPermission: "write",
     security: { type: "oauth2", scopes: [chalksurfMcpScopes.write] }
   },
+  delete_exercise: {
+    name: "delete_exercise",
+    title: "Delete exercise",
+    description: "Use this to soft-delete one writable exercise after checking updated_at and exact destructive confirmation.",
+    inputSchema: deleteExerciseInputSchema,
+    outputSchema: deleteExerciseOutputSchema,
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+    requiredPermission: "write",
+    security: { type: "oauth2", scopes: [chalksurfMcpScopes.write] }
+  },
+  create_exercise: {
+    name: "create_exercise",
+    title: "Create exercise",
+    description: "Use this to create one exercise in the selected ChalkSurf organization.",
+    inputSchema: createExerciseInputSchema,
+    outputSchema: createExerciseOutputSchema,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    requiredPermission: "write",
+    security: { type: "oauth2", scopes: [chalksurfMcpScopes.write] }
+  },
   update_exercise: {
     name: "update_exercise",
     title: "Update exercise",
@@ -1713,6 +2666,16 @@ var chalksurfMcpToolCapabilities = {
     requiredPermission: "write",
     security: { type: "oauth2", scopes: [chalksurfMcpScopes.write] }
   },
+  set_exercise_visibility: {
+    name: "set_exercise_visibility",
+    title: "Set exercise visibility",
+    description: "Use this to make one writable exercise public or private after checking updated_at and visibility policy.",
+    inputSchema: setExerciseVisibilityInputSchema,
+    outputSchema: setExerciseVisibilityOutputSchema,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    requiredPermission: "write",
+    security: { type: "oauth2", scopes: [chalksurfMcpScopes.write] }
+  },
   import_exercise: {
     name: "import_exercise",
     title: "Import exercise",
@@ -1753,6 +2716,26 @@ var chalksurfMcpToolCapabilities = {
     requiredPermission: "read",
     security: { type: "oauth2", scopes: [chalksurfMcpScopes.read] }
   },
+  list_sheet_versions: {
+    name: "list_sheet_versions",
+    title: "List sheet versions",
+    description: "Use this to inspect the version history for one owned exercise sheet.",
+    inputSchema: listSheetVersionsInputSchema,
+    outputSchema: listSheetVersionsOutputSchema,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    requiredPermission: "read",
+    security: { type: "oauth2", scopes: [chalksurfMcpScopes.read] }
+  },
+  get_sheet_version: {
+    name: "get_sheet_version",
+    title: "Get sheet version",
+    description: "Use this to fetch one owned exercise sheet version snapshot with its referenced exercise details.",
+    inputSchema: getSheetVersionInputSchema,
+    outputSchema: getSheetVersionOutputSchema,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    requiredPermission: "read",
+    security: { type: "oauth2", scopes: [chalksurfMcpScopes.read] }
+  },
   get_sheet_issues: {
     name: "get_sheet_issues",
     title: "Get sheet issues",
@@ -1773,6 +2756,26 @@ var chalksurfMcpToolCapabilities = {
     requiredPermission: "write",
     security: { type: "oauth2", scopes: [chalksurfMcpScopes.write] }
   },
+  delete_sheet: {
+    name: "delete_sheet",
+    title: "Delete sheet",
+    description: "Use this to soft-delete one writable exercise sheet after checking updated_at and exact destructive confirmation.",
+    inputSchema: deleteSheetInputSchema,
+    outputSchema: deleteSheetOutputSchema,
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+    requiredPermission: "write",
+    security: { type: "oauth2", scopes: [chalksurfMcpScopes.write] }
+  },
+  create_sheet: {
+    name: "create_sheet",
+    title: "Create sheet",
+    description: "Use this to create one exercise sheet in the selected ChalkSurf organization.",
+    inputSchema: createSheetInputSchema,
+    outputSchema: createSheetOutputSchema,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    requiredPermission: "write",
+    security: { type: "oauth2", scopes: [chalksurfMcpScopes.write] }
+  },
   update_sheet: {
     name: "update_sheet",
     title: "Update sheet",
@@ -1783,6 +2786,16 @@ var chalksurfMcpToolCapabilities = {
     requiredPermission: "write",
     security: { type: "oauth2", scopes: [chalksurfMcpScopes.write] }
   },
+  set_sheet_visibility: {
+    name: "set_sheet_visibility",
+    title: "Set sheet visibility",
+    description: "Use this to make one writable exercise sheet public or private after checking updated_at and visibility policy.",
+    inputSchema: setSheetVisibilityInputSchema,
+    outputSchema: setSheetVisibilityOutputSchema,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    requiredPermission: "write",
+    security: { type: "oauth2", scopes: [chalksurfMcpScopes.write] }
+  },
   append_exercises_to_sheet: {
     name: "append_exercises_to_sheet",
     title: "Append exercises to sheet",
@@ -1803,6 +2816,36 @@ var chalksurfMcpToolCapabilities = {
     requiredPermission: "read",
     security: { type: "oauth2", scopes: [chalksurfMcpScopes.read] }
   },
+  send_user_feedback: {
+    name: "send_user_feedback",
+    title: "Send user feedback",
+    description: "Use this only after the user explicitly asks you to send feedback or agrees to send a bug report or feature request.",
+    inputSchema: sendUserFeedbackInputSchema,
+    outputSchema: sendUserFeedbackOutputSchema,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    requiredPermission: "read",
+    security: { type: "oauth2", scopes: [chalksurfMcpScopes.read] }
+  },
+  send_agent_feedback: {
+    name: "send_agent_feedback",
+    title: "Send agent feedback",
+    description: "Use this when you observe a ChalkSurf CLI, MCP, API, or documentation inconsistency while using agent tools.",
+    inputSchema: sendAgentFeedbackInputSchema,
+    outputSchema: sendAgentFeedbackOutputSchema,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    requiredPermission: "read",
+    security: { type: "oauth2", scopes: [chalksurfMcpScopes.read] }
+  },
+  delete_folder: {
+    name: "delete_folder",
+    title: "Delete folder",
+    description: "Use this to delete one empty exercise sheet folder after exact destructive confirmation.",
+    inputSchema: deleteFolderInputSchema,
+    outputSchema: deleteFolderOutputSchema,
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+    requiredPermission: "write",
+    security: { type: "oauth2", scopes: [chalksurfMcpScopes.write] }
+  },
   create_folder: {
     name: "create_folder",
     title: "Create folder",
@@ -1883,14 +2926,582 @@ var chalksurfMcpToolCapabilities = {
     requiredPermission: "read",
     security: { type: "oauth2", scopes: [chalksurfMcpScopes.read] }
   }
-};
+};
+
+// ../shared/src/export-layout/preview-layout-settings.ts
+import { z as z4 } from "zod";
+var worksheetPreviewLayoutSettingsVersion = 1;
+var worksheetWorkspaceFillModes = ["empty", "lines", "grid"];
+var worksheetPreviewLayoutSettingsLimits = {
+  fontSizePt: {
+    min: 8,
+    max: 18,
+    default: 12
+  },
+  figureWidthInCm: {
+    min: 1,
+    max: 16,
+    default: 6
+  },
+  workspaceHeightInCm: {
+    min: 1,
+    max: 12,
+    default: 4
+  }
+};
+var defaultWorksheetPreviewLayoutSettings = {
+  version: worksheetPreviewLayoutSettingsVersion,
+  fontSizePt: worksheetPreviewLayoutSettingsLimits.fontSizePt.default,
+  figureOverridesByBlockId: {},
+  workspaceOverridesByExerciseId: {}
+};
+var finiteNumberSchema = z4.number().finite();
+var worksheetPreviewLayoutSettingsSchema = z4.object({
+  version: z4.literal(worksheetPreviewLayoutSettingsVersion),
+  fontSizePt: finiteNumberSchema.optional(),
+  figureOverridesByBlockId: z4.record(
+    z4.string().min(1),
+    z4.object({
+      widthInCm: finiteNumberSchema.optional(),
+      placement: z4.unknown().optional()
+    })
+  ).optional(),
+  workspaceOverridesByExerciseId: z4.record(
+    z4.string().min(1),
+    z4.object({
+      heightInCm: finiteNumberSchema.optional(),
+      fillMode: z4.unknown().optional()
+    })
+  ).optional()
+});
+
+// ../shared/src/export-layout/types.ts
+import { z as z5 } from "zod";
+var worksheetLayoutVersion = 1;
+var defaultWorksheetPageSettings = {
+  size: "A4",
+  widthMm: 210,
+  heightMm: 297,
+  marginMm: {
+    top: 16,
+    right: 18,
+    bottom: 16,
+    left: 18
+  }
+};
+var worksheetLayoutBlockTypes = [
+  "sheet-title",
+  "sheet-description",
+  "exercise",
+  "exercise-text",
+  "figure",
+  "workspace",
+  "answer",
+  "detailed-solution"
+];
+var baseWorksheetLayoutBlockSchema = z5.object({
+  id: z5.string().min(1),
+  type: z5.enum(worksheetLayoutBlockTypes),
+  exerciseId: z5.string().min(1).optional()
+});
+var worksheetLayoutBlockSchema = z5.lazy(
+  () => z5.discriminatedUnion("type", [
+    baseWorksheetLayoutBlockSchema.extend({
+      type: z5.literal("sheet-title"),
+      text: z5.string()
+    }),
+    baseWorksheetLayoutBlockSchema.extend({
+      type: z5.literal("sheet-description"),
+      text: z5.string()
+    }),
+    baseWorksheetLayoutBlockSchema.extend({
+      type: z5.literal("exercise-text"),
+      exerciseId: z5.string().min(1),
+      text: z5.string()
+    }),
+    baseWorksheetLayoutBlockSchema.extend({
+      type: z5.literal("answer"),
+      exerciseId: z5.string().min(1),
+      text: z5.string()
+    }),
+    baseWorksheetLayoutBlockSchema.extend({
+      type: z5.literal("detailed-solution"),
+      exerciseId: z5.string().min(1),
+      text: z5.string()
+    }),
+    baseWorksheetLayoutBlockSchema.extend({
+      type: z5.literal("exercise"),
+      exerciseId: z5.string().min(1),
+      exerciseNumber: z5.number().int().positive(),
+      scorePoints: z5.number().nullable(),
+      children: z5.array(worksheetLayoutBlockSchema)
+    }),
+    baseWorksheetLayoutBlockSchema.extend({
+      type: z5.literal("figure"),
+      exerciseId: z5.string().min(1),
+      figure: z5.object({
+        type: z5.enum(["text", "solution"]),
+        url: z5.string(),
+        widthInCm: z5.number().positive()
+      }),
+      figureNumber: z5.number().int().positive()
+    }),
+    baseWorksheetLayoutBlockSchema.extend({
+      type: z5.literal("workspace"),
+      exerciseId: z5.string().min(1),
+      heightInCm: z5.number().nonnegative(),
+      fillMode: z5.enum(worksheetWorkspaceFillModes)
+    })
+  ])
+);
+var worksheetLayoutDocumentSchema = z5.object({
+  version: z5.literal(worksheetLayoutVersion),
+  title: z5.string(),
+  description: z5.string().nullable(),
+  language: z5.enum(translationLanguages),
+  blocks: z5.array(worksheetLayoutBlockSchema)
+});
+var worksheetRenderDiagnosticCodes = [
+  "unclosed_latex_delimiter",
+  "katex_render_error",
+  "missing_katex_renderer",
+  "image_load_error",
+  "html_render_error",
+  "layout_measurement_error",
+  "page_overflow"
+];
+var worksheetPageSegmentSchema = z5.discriminatedUnion("type", [
+  z5.object({
+    type: z5.literal("standalone"),
+    unitId: z5.string().min(1),
+    blockId: z5.string().min(1),
+    heightPx: z5.number().finite().nonnegative()
+  }),
+  z5.object({
+    type: z5.literal("exercise"),
+    unitId: z5.string().min(1),
+    blockId: z5.string().min(1),
+    exerciseId: z5.string().min(1),
+    includeHeading: z5.boolean(),
+    childUnitIds: z5.array(z5.string().min(1)),
+    heightPx: z5.number().finite().nonnegative(),
+    isContinuation: z5.boolean(),
+    overflow: z5.boolean()
+  })
+]);
+var worksheetPaginationPlanSchema = z5.object({
+  pages: z5.array(
+    z5.object({
+      pageNumber: z5.number().int().positive(),
+      segments: z5.array(worksheetPageSegmentSchema),
+      usedHeightPx: z5.number().finite().nonnegative()
+    })
+  ),
+  diagnostics: z5.array(
+    z5.object({
+      code: z5.enum(worksheetRenderDiagnosticCodes),
+      severity: z5.enum(["error", "warning"]),
+      message: z5.string(),
+      blockId: z5.string().optional(),
+      exerciseId: z5.string().optional(),
+      snippet: z5.string().optional()
+    })
+  ),
+  metrics: z5.object({
+    pageCount: z5.number().int().positive(),
+    measuredUnitCount: z5.number().int().nonnegative(),
+    overflowCount: z5.number().int().nonnegative()
+  })
+});
+
+// ../shared/src/export-layout/document-css.ts
+var { heightMm, marginMm, widthMm } = defaultWorksheetPageSettings;
+var worksheetDocumentCss = `
+@page {
+  size: ${widthMm}mm ${heightMm}mm;
+  margin: 0;
+}
+
+.cs-worksheet {
+  box-sizing: border-box;
+  color: #111;
+  font-family: "STIX Two Text", "Latin Modern Roman", "Libertinus Serif", Cambria, Georgia, serif;
+  font-size: 12pt;
+  line-height: 1.45;
+}
+
+.cs-worksheet *,
+.cs-worksheet *::before,
+.cs-worksheet *::after {
+  box-sizing: border-box;
+}
+
+.cs-worksheet .katex {
+  padding: 0;
+}
+
+.cs-worksheet--continuous {
+  width: ${widthMm}mm;
+  padding: ${marginMm.top}mm ${marginMm.right}mm ${marginMm.bottom}mm ${marginMm.left}mm;
+  background: #fff;
+}
+
+.cs-worksheet--paged {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+
+.cs-worksheet__page {
+  width: ${widthMm}mm;
+  min-height: ${heightMm}mm;
+  margin-left: auto;
+  margin-right: auto;
+  padding: ${marginMm.top}mm ${marginMm.right}mm ${marginMm.bottom}mm ${marginMm.left}mm;
+  background: #fff;
+  box-shadow: 0 4px 18px rgba(0, 0, 0, 0.18);
+}
+
+.cs-worksheet__title {
+  margin: 0 0 40px;
+  font-size: 20pt;
+  font-weight: 700;
+  line-height: 1.2;
+  text-align: center;
+}
+
+.cs-worksheet__exercise-list {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.cs-worksheet__exercise {
+  margin-bottom: 32px;
+  break-inside: avoid;
+}
+
+.cs-worksheet__exercise:last-child {
+  margin-bottom: 0;
+}
+
+.cs-worksheet__exercise-heading {
+  display: flex;
+  justify-content: space-between;
+  align-items: baseline;
+  gap: 16px;
+  margin-bottom: 8px;
+}
+
+.cs-worksheet__exercise-title {
+  margin: 0;
+  font-size: 13pt;
+  font-weight: 700;
+  line-height: 1.3;
+}
+
+.cs-worksheet__exercise-score {
+  font-size: 10pt;
+  white-space: nowrap;
+}
+
+.cs-worksheet__exercise-text,
+.cs-worksheet__subsection-content {
+  overflow-wrap: anywhere;
+}
+
+.cs-worksheet__exercise-text::after,
+.cs-worksheet__subsection-content::after {
+  content: "";
+  display: block;
+  clear: both;
+}
+
+.cs-worksheet__math--display {
+  display: block;
+  margin-top: 8px;
+  margin-bottom: 8px;
+  text-align: center;
+}
+
+.cs-worksheet__figure {
+  margin: 16px 0;
+  text-align: center;
+  break-inside: avoid;
+  position: relative;
+  outline-offset: 2px;
+}
+
+.cs-worksheet__figure--left {
+  text-align: left;
+}
+
+.cs-worksheet__figure--center {
+  text-align: center;
+}
+
+.cs-worksheet__figure--right {
+  text-align: right;
+}
+
+.cs-worksheet__figure--float-left {
+  float: left;
+  max-width: 55%;
+  margin: 0 12px 8px 0;
+  text-align: left;
+}
+
+.cs-worksheet__figure--float-right {
+  float: right;
+  max-width: 55%;
+  margin: 0 0 8px 12px;
+  text-align: right;
+}
+
+.cs-worksheet__figure img {
+  height: auto;
+}
+
+.cs-worksheet__figure-row {
+  display: flex;
+  flex-wrap: nowrap;
+  align-items: flex-start;
+  margin-top: 16px;
+  margin-bottom: 16px;
+  break-inside: avoid;
+  clear: both;
+  width: 100%;
+}
+
+.cs-worksheet__figure-row-spacer {
+  flex: 1 1 auto;
+  min-width: 0;
+}
+
+.cs-worksheet__figure-row-slot {
+  display: flex;
+  flex: 0 0 auto;
+  align-items: flex-start;
+  gap: 8mm;
+  min-width: 0;
+}
+
+.cs-worksheet__figure-row-slot--left {
+  justify-content: flex-start;
+}
+
+.cs-worksheet__figure-row-slot--center {
+  justify-content: center;
+}
+
+.cs-worksheet__figure-row-slot--right {
+  justify-content: flex-end;
+}
+
+.cs-worksheet__figure-row .cs-worksheet__figure {
+  margin-top: 0;
+  margin-bottom: 0;
+  flex: 0 1 auto;
+}
+
+.cs-worksheet__workspace {
+  margin-top: 12px;
+  break-inside: avoid;
+  background-color: #fff;
+  -webkit-print-color-adjust: exact;
+  print-color-adjust: exact;
+  outline-offset: 2px;
+  clear: both;
+}
+
+.cs-worksheet__workspace--lines {
+  background-image: linear-gradient(
+    to bottom,
+    #c9d4dc 0,
+    #c9d4dc 0.2mm,
+    transparent 0.2mm
+  );
+  background-size: 100% 7mm;
+  background-repeat: repeat;
+}
+
+.cs-worksheet__workspace--grid {
+  background-image:
+    linear-gradient(
+      to right,
+      #d3dce3 0,
+      #d3dce3 0.2mm,
+      transparent 0.2mm
+    ),
+    linear-gradient(
+      to bottom,
+      #d3dce3 0,
+      #d3dce3 0.2mm,
+      transparent 0.2mm
+    );
+  background-size: 5mm 5mm;
+  background-repeat: repeat;
+}
+
+.cs-worksheet__subsection {
+  margin-top: 16px;
+  break-inside: avoid;
+  clear: both;
+}
+
+.cs-worksheet__subsection-title {
+  margin: 0 0 4px;
+  font-size: 11pt;
+  font-weight: 700;
+}
+
+@media print {
+  .cs-worksheet--paged {
+    display: block;
+    gap: 0;
+  }
+
+  .cs-worksheet__page {
+    margin: 0;
+    box-shadow: none;
+    break-after: page;
+    page-break-after: always;
+  }
+
+  .cs-worksheet__page:last-child {
+    break-after: auto;
+    page-break-after: auto;
+  }
+}
+`.trim();
+var worksheetHtmlDocumentShellCss = `
+html,
+body {
+  margin: 0;
+  padding: 0;
+}
+`.trim();
+
+// ../shared/src/export-layout/html-pdf-export.ts
+import { z as z6 } from "zod";
+var worksheetHtmlPdfExportPayloadVersion = 1;
+var worksheetHtmlPdfExportPayloadSchema = z6.object({
+  version: z6.literal(worksheetHtmlPdfExportPayloadVersion),
+  layoutSettings: worksheetPreviewLayoutSettingsSchema,
+  paginationPlan: worksheetPaginationPlanSchema
+});
+var scorePointsSchema = z6.number().min(0, "Score must be greater than or equal to 0").max(99999.9, "Score must be less than or equal to 99999.9").refine((value) => Number.isInteger(value * 10), "Score can have at most 1 decimal place");
+var worksheetExportTemplateInputShape = {
+  language: z6.enum(translationLanguages),
+  templateId: z6.enum(exportTemplateIds).default("exercises"),
+  parameters: z6.record(z6.string(), z6.unknown()).default({}),
+  layoutSettings: worksheetPreviewLayoutSettingsSchema.optional()
+};
+var worksheetPersistedExportSourceInputSchema = z6.object({
+  source: z6.enum(["saved-sheet", "public-sheet"]).default("saved-sheet"),
+  id: z6.uuid(),
+  ...worksheetExportTemplateInputShape
+});
+var worksheetLocalExportExerciseInputSchema = z6.object({
+  id: z6.uuid("Invalid UUID"),
+  scorePoints: scorePointsSchema.nullable()
+});
+var worksheetLocalExportSourceInputSchema = z6.object({
+  source: z6.literal("local-sheet"),
+  title: z6.string().trim().min(1, "Title is required"),
+  scoringEnabled: z6.boolean().default(false),
+  exercises: z6.array(worksheetLocalExportExerciseInputSchema).max(100).default([]),
+  ...worksheetExportTemplateInputShape
+});
+var worksheetExportSourceInputSchema = z6.union([
+  worksheetPersistedExportSourceInputSchema,
+  worksheetLocalExportSourceInputSchema
+]);
+var worksheetHtmlPdfExportInputSchema = z6.union([
+  worksheetPersistedExportSourceInputSchema.extend({
+    htmlExport: worksheetHtmlPdfExportPayloadSchema
+  }),
+  worksheetLocalExportSourceInputSchema.extend({
+    htmlExport: worksheetHtmlPdfExportPayloadSchema
+  })
+]);
+
+// ../../node_modules/entities/dist/esm/decode-codepoint.js
+var _a;
+var fromCodePoint = (
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, n/no-unsupported-features/es-builtins
+  (_a = String.fromCodePoint) !== null && _a !== void 0 ? _a : function(codePoint) {
+    let output = "";
+    if (codePoint > 65535) {
+      codePoint -= 65536;
+      output += String.fromCharCode(codePoint >>> 10 & 1023 | 55296);
+      codePoint = 56320 | codePoint & 1023;
+    }
+    output += String.fromCharCode(codePoint);
+    return output;
+  }
+);
 
-// ../shared/src/helpers/latex/exercise-translation-latex.ts
-var hintField = "hint";
-var isLatexWholeField = (field) => {
-  return field !== hintField;
-};
-var exerciseTranslationLatexWholeFields = exerciseTranslationFields.filter(isLatexWholeField);
+// ../../node_modules/entities/dist/esm/decode.js
+var CharCodes;
+(function(CharCodes2) {
+  CharCodes2[CharCodes2["NUM"] = 35] = "NUM";
+  CharCodes2[CharCodes2["SEMI"] = 59] = "SEMI";
+  CharCodes2[CharCodes2["EQUALS"] = 61] = "EQUALS";
+  CharCodes2[CharCodes2["ZERO"] = 48] = "ZERO";
+  CharCodes2[CharCodes2["NINE"] = 57] = "NINE";
+  CharCodes2[CharCodes2["LOWER_A"] = 97] = "LOWER_A";
+  CharCodes2[CharCodes2["LOWER_F"] = 102] = "LOWER_F";
+  CharCodes2[CharCodes2["LOWER_X"] = 120] = "LOWER_X";
+  CharCodes2[CharCodes2["LOWER_Z"] = 122] = "LOWER_Z";
+  CharCodes2[CharCodes2["UPPER_A"] = 65] = "UPPER_A";
+  CharCodes2[CharCodes2["UPPER_F"] = 70] = "UPPER_F";
+  CharCodes2[CharCodes2["UPPER_Z"] = 90] = "UPPER_Z";
+})(CharCodes || (CharCodes = {}));
+var BinTrieFlags;
+(function(BinTrieFlags2) {
+  BinTrieFlags2[BinTrieFlags2["VALUE_LENGTH"] = 49152] = "VALUE_LENGTH";
+  BinTrieFlags2[BinTrieFlags2["BRANCH_LENGTH"] = 16256] = "BRANCH_LENGTH";
+  BinTrieFlags2[BinTrieFlags2["JUMP_TABLE"] = 127] = "JUMP_TABLE";
+})(BinTrieFlags || (BinTrieFlags = {}));
+var EntityDecoderState;
+(function(EntityDecoderState2) {
+  EntityDecoderState2[EntityDecoderState2["EntityStart"] = 0] = "EntityStart";
+  EntityDecoderState2[EntityDecoderState2["NumericStart"] = 1] = "NumericStart";
+  EntityDecoderState2[EntityDecoderState2["NumericDecimal"] = 2] = "NumericDecimal";
+  EntityDecoderState2[EntityDecoderState2["NumericHex"] = 3] = "NumericHex";
+  EntityDecoderState2[EntityDecoderState2["NamedEntity"] = 4] = "NamedEntity";
+})(EntityDecoderState || (EntityDecoderState = {}));
+var DecodingMode;
+(function(DecodingMode2) {
+  DecodingMode2[DecodingMode2["Legacy"] = 0] = "Legacy";
+  DecodingMode2[DecodingMode2["Strict"] = 1] = "Strict";
+  DecodingMode2[DecodingMode2["Attribute"] = 2] = "Attribute";
+})(DecodingMode || (DecodingMode = {}));
+
+// ../../node_modules/entities/dist/esm/escape.js
+var getCodePoint = (
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  String.prototype.codePointAt == null ? (c, index) => (c.charCodeAt(index) & 64512) === 55296 ? (c.charCodeAt(index) - 55296) * 1024 + c.charCodeAt(index + 1) - 56320 + 65536 : c.charCodeAt(index) : (
+    // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+    (input, index) => input.codePointAt(index)
+  )
+);
+
+// ../../node_modules/entities/dist/esm/index.js
+var EntityLevel;
+(function(EntityLevel2) {
+  EntityLevel2[EntityLevel2["XML"] = 0] = "XML";
+  EntityLevel2[EntityLevel2["HTML"] = 1] = "HTML";
+})(EntityLevel || (EntityLevel = {}));
+var EncodingMode;
+(function(EncodingMode2) {
+  EncodingMode2[EncodingMode2["UTF8"] = 0] = "UTF8";
+  EncodingMode2[EncodingMode2["ASCII"] = 1] = "ASCII";
+  EncodingMode2[EncodingMode2["Extensive"] = 2] = "Extensive";
+  EncodingMode2[EncodingMode2["Attribute"] = 3] = "Attribute";
+  EncodingMode2[EncodingMode2["Text"] = 4] = "Text";
+})(EncodingMode || (EncodingMode = {}));
 
 // ../shared/src/helpers/latex/latex-helpers.ts
 var latexDelimiters = [
@@ -1903,185 +3514,241 @@ var sortedLatexDelimiters = [...latexDelimiters].sort((leftDelimiter, rightDelim
   return rightDelimiter.left.length - leftDelimiter.left.length;
 });
 
+// ../shared/src/export-layout/render-html.ts
+var worksheetContentWidthInCm = (defaultWorksheetPageSettings.widthMm - defaultWorksheetPageSettings.marginMm.left - defaultWorksheetPageSettings.marginMm.right) / 10;
+
+// ../shared/src/helpers/exercise-labels.ts
+var exerciseLabels = labels_default;
+var flattenExerciseLabels = (labelNodes = exerciseLabels) => {
+  const seenIds = /* @__PURE__ */ new Set();
+  const flattenedLabels = [];
+  const visit = ({
+    depth,
+    node,
+    parentId,
+    pathIds,
+    pathNames
+  }) => {
+    if (seenIds.has(node.id)) {
+      throw new Error(`Duplicate exercise label id: ${node.id}`);
+    }
+    seenIds.add(node.id);
+    const childIds = node.children?.map((child) => child.id) ?? [];
+    const nextPathIds = [...pathIds, node.id];
+    const nextPathNames = [...pathNames, node.name];
+    flattenedLabels.push({
+      id: node.id,
+      name: node.name,
+      parentId,
+      depth,
+      pathIds: nextPathIds,
+      pathNames: nextPathNames,
+      displayPath: nextPathNames.join(" / "),
+      childIds
+    });
+    node.children?.forEach((child) => {
+      visit({
+        depth: depth + 1,
+        node: child,
+        parentId: node.id,
+        pathIds: nextPathIds,
+        pathNames: nextPathNames
+      });
+    });
+  };
+  labelNodes.forEach((node) => {
+    visit({ depth: 0, node, parentId: null, pathIds: [], pathNames: [] });
+  });
+  return flattenedLabels;
+};
+var canonicalExerciseLabelIds = new Set(flattenExerciseLabels().map((label) => label.id));
+
+// ../shared/src/helpers/latex/exercise-translation-latex.ts
+var hintField = "hint";
+var isLatexWholeField = (field) => {
+  return field !== hintField;
+};
+var exerciseTranslationLatexWholeFields = exerciseTranslationFields.filter(isLatexWholeField);
+
 // ../shared/src/schemas/model-output-schemas.ts
-import z4 from "zod";
-var importFigureCandidateIdsSchema = z4.array(z4.string()).optional();
-var exerciseTranslationOutputSchema = z4.object({
-  translations: z4.object({
-    exercise_text: z4.string().trim().min(1).nullable(),
-    description: z4.string().trim().min(1).nullable(),
-    hint: z4.string().trim().min(1).nullable(),
-    answer: z4.string().trim().min(1).nullable(),
-    scaffold: z4.string().trim().min(1).nullable(),
-    detailed_solution: z4.string().trim().min(1).nullable()
+import z7 from "zod";
+var importFigureCandidateIdsSchema = z7.array(z7.string()).optional();
+var exerciseTranslationOutputSchema = z7.object({
+  translations: z7.object({
+    exercise_text: z7.string().trim().min(1).nullable(),
+    description: z7.string().trim().min(1).nullable(),
+    hint: z7.string().trim().min(1).nullable(),
+    answer: z7.string().trim().min(1).nullable(),
+    scaffold: z7.string().trim().min(1).nullable(),
+    detailed_solution: z7.string().trim().min(1).nullable()
   })
 });
-var sheetTranslationFieldSchema = z4.string().trim().min(1);
-var exerciseSheetTranslationOutputSchema = z4.object({
-  translations: z4.object(
+var sheetTranslationFieldSchema = z7.string().trim().min(1);
+var exerciseSheetTranslationOutputSchema = z7.object({
+  translations: z7.object(
     Object.fromEntries(
       exerciseSheetTranslationFields.map((field) => [field, sheetTranslationFieldSchema.nullable()])
     )
   ).strict()
 });
-var generatedTranslationFieldSchema = z4.string().trim().min(1);
-var generatedTranslationFieldsSchema = z4.object(
+var generatedTranslationFieldSchema = z7.string().trim().min(1);
+var generatedTranslationFieldsSchema = z7.object(
   Object.fromEntries(
     exerciseTranslationFields.map((field) => [field, generatedTranslationFieldSchema.nullable()])
   )
 ).strict();
-var exerciseSolutionImportOutputSchema = z4.object({
-  language: z4.enum(translationLanguages),
-  hints: z4.array(z4.string()).nullable(),
-  answer: z4.string().nullable(),
-  scaffold: z4.string().nullable(),
-  detailedSolution: z4.string().nullable(),
-  notes: z4.string().nullable(),
+var exerciseSolutionImportOutputSchema = z7.object({
+  language: z7.enum(translationLanguages),
+  hints: z7.array(z7.string()).nullable(),
+  answer: z7.string().nullable(),
+  scaffold: z7.string().nullable(),
+  detailedSolution: z7.string().nullable(),
+  notes: z7.string().nullable(),
   solutionFigureCandidateIds: importFigureCandidateIdsSchema
 });
-var generatedSolutionFieldsSchema = z4.object({
-  hints: z4.array(z4.string().trim().min(1)).min(1).nullable(),
-  answer: z4.string().trim().min(1).nullable(),
-  scaffold: z4.string().trim().min(1).nullable(),
-  detailedSolution: z4.string().trim().min(1).nullable()
+var generatedSolutionFieldsSchema = z7.object({
+  hints: z7.array(z7.string().trim().min(1)).min(1).nullable(),
+  answer: z7.string().trim().min(1).nullable(),
+  scaffold: z7.string().trim().min(1).nullable(),
+  detailedSolution: z7.string().trim().min(1).nullable()
 }).strict();
-var sheetImportExerciseOutputSchema = z4.object({
-  text: z4.string(),
-  detailedSolution: z4.string().nullable(),
-  hints: z4.array(z4.string()).nullable(),
-  scaffold: z4.string().nullable(),
-  answer: z4.string().nullable(),
-  source: z4.string().nullable(),
-  notes: z4.string().nullable(),
+var sheetImportExerciseOutputSchema = z7.object({
+  text: z7.string(),
+  detailedSolution: z7.string().nullable(),
+  hints: z7.array(z7.string()).nullable(),
+  scaffold: z7.string().nullable(),
+  answer: z7.string().nullable(),
+  source: z7.string().nullable(),
+  notes: z7.string().nullable(),
   textFigureCandidateIds: importFigureCandidateIdsSchema,
   solutionFigureCandidateIds: importFigureCandidateIdsSchema
 }).strict();
-var sheetImportOutputSchema = z4.object({
-  isExerciseSheet: z4.boolean(),
-  title: z4.string(),
-  description: z4.string().nullable(),
-  language: z4.enum(translationLanguages),
-  exercises: z4.array(sheetImportExerciseOutputSchema)
+var sheetImportOutputSchema = z7.object({
+  isExerciseSheet: z7.boolean(),
+  title: z7.string(),
+  description: z7.string().nullable(),
+  language: z7.enum(translationLanguages),
+  exercises: z7.array(sheetImportExerciseOutputSchema)
 }).strict();
-var exerciseImportOutputSchema = z4.object({
-  exercises: z4.array(
-    z4.object({
-      language: z4.enum(translationLanguages),
-      text: z4.string(),
-      detailedSolution: z4.string().nullable(),
-      hints: z4.array(z4.string()).nullable(),
-      scaffold: z4.string().nullable(),
-      answer: z4.string().nullable(),
-      source: z4.string().nullable(),
-      notes: z4.string().nullable(),
+var exerciseImportOutputSchema = z7.object({
+  exercises: z7.array(
+    z7.object({
+      language: z7.enum(translationLanguages),
+      text: z7.string(),
+      detailedSolution: z7.string().nullable(),
+      hints: z7.array(z7.string()).nullable(),
+      scaffold: z7.string().nullable(),
+      answer: z7.string().nullable(),
+      source: z7.string().nullable(),
+      notes: z7.string().nullable(),
       textFigureCandidateIds: importFigureCandidateIdsSchema,
       solutionFigureCandidateIds: importFigureCandidateIdsSchema
     })
   )
 });
-var komalPdfExerciseOutputSchema = z4.object({
-  exercise_text_latex: z4.string().describe("The parsed exercise text with LaTeX formulas delimited by $ signs"),
-  language: z4.enum(translationLanguages).describe("The language of the exercise"),
-  subject: z4.enum(exerciseSubjects).describe("The subject of the exercise")
+var komalPdfExerciseOutputSchema = z7.object({
+  exercise_text_latex: z7.string().describe("The parsed exercise text with LaTeX formulas delimited by $ signs"),
+  language: z7.enum(translationLanguages).describe("The language of the exercise"),
+  subject: z7.enum(exerciseSubjects).describe("The subject of the exercise")
 });
 
 // ../shared/src/schemas/pgmq.ts
-import { z as z5 } from "zod";
-var importFileSchema = z5.object({
-  fileName: z5.string(),
-  fileType: z5.string(),
-  storageFilePath: z5.string()
+import { z as z8 } from "zod";
+var importFileSchema = z8.object({
+  fileName: z8.string(),
+  fileType: z8.string(),
+  storageFilePath: z8.string()
 });
-var declaredSheetImportComponentSchema = z5.object({
+var declaredSheetImportComponentSchema = z8.object({
   componentId: sheetImportComponentIdSchema,
-  description: z5.string().trim().min(1),
-  folderId: z5.string().nullable(),
-  titleOverride: z5.string().trim().min(1).nullable().optional(),
+  description: z8.string().trim().min(1),
+  folderId: z8.string().nullable(),
+  titleOverride: z8.string().trim().min(1).nullable().optional(),
   translateToLanguages: sheetImportTranslationLanguageListSchema.optional()
 }).strict();
-var exerciseSheetImportQueueMessageSchema = z5.object({
-  userId: z5.string(),
-  organizationId: z5.uuid(),
-  files: z5.array(importFileSchema),
-  jobId: z5.string(),
-  folderId: z5.string().nullable(),
-  docxGotenbergConversionEnabled: z5.boolean().optional(),
-  titleOverride: z5.string().nullable().optional(),
-  translateToLanguages: z5.array(z5.enum(translationLanguages)).refine((languages) => new Set(languages).size === languages.length, {
+var exerciseSheetImportQueueMessageSchema = z8.object({
+  userId: z8.string(),
+  organizationId: z8.uuid(),
+  files: z8.array(importFileSchema),
+  jobId: z8.string(),
+  folderId: z8.string().nullable(),
+  docxGotenbergConversionEnabled: z8.boolean().optional(),
+  titleOverride: z8.string().nullable().optional(),
+  translateToLanguages: z8.array(z8.enum(translationLanguages)).refine((languages) => new Set(languages).size === languages.length, {
     message: "translateToLanguages must be unique"
   }).optional(),
-  declaredComponents: z5.array(declaredSheetImportComponentSchema).min(1).optional()
-});
-var exerciseSolutionImportQueueMessageSchema = z5.object({
-  userId: z5.string(),
-  organizationId: z5.uuid(),
-  exerciseId: z5.uuid(),
-  files: z5.array(importFileSchema),
-  jobId: z5.string(),
-  docxGotenbergConversionEnabled: z5.boolean().optional()
-});
-var exerciseSheetSolutionImportQueueMessageSchema = z5.object({
-  userId: z5.string(),
-  organizationId: z5.uuid(),
-  exerciseSheetId: z5.uuid(),
-  files: z5.array(importFileSchema),
-  jobId: z5.string(),
-  docxGotenbergConversionEnabled: z5.boolean().optional()
-});
-var exerciseSolutionGenerationQueueMessageSchema = z5.object({
-  userId: z5.uuid(),
-  organizationId: z5.uuid(),
-  exerciseId: z5.uuid(),
-  exerciseSheetId: z5.uuid().optional(),
-  batchId: z5.uuid().optional(),
-  jobId: z5.uuid()
-});
-var exerciseTranslationGenerationQueueMessageSchema = z5.object({
-  userId: z5.uuid(),
-  organizationId: z5.uuid(),
-  exerciseId: z5.uuid(),
-  jobId: z5.uuid(),
-  languages: z5.array(z5.enum(translationLanguages)).min(1)
+  declaredComponents: z8.array(declaredSheetImportComponentSchema).min(1).optional()
+});
+var exerciseSolutionImportQueueMessageSchema = z8.object({
+  userId: z8.string(),
+  organizationId: z8.uuid(),
+  exerciseId: z8.uuid(),
+  files: z8.array(importFileSchema),
+  jobId: z8.string(),
+  docxGotenbergConversionEnabled: z8.boolean().optional()
+});
+var exerciseSheetSolutionImportQueueMessageSchema = z8.object({
+  userId: z8.string(),
+  organizationId: z8.uuid(),
+  exerciseSheetId: z8.uuid(),
+  files: z8.array(importFileSchema),
+  jobId: z8.string(),
+  docxGotenbergConversionEnabled: z8.boolean().optional()
+});
+var exerciseSolutionGenerationQueueMessageSchema = z8.object({
+  userId: z8.uuid(),
+  organizationId: z8.uuid(),
+  exerciseId: z8.uuid(),
+  exerciseSheetId: z8.uuid().optional(),
+  batchId: z8.uuid().optional(),
+  jobId: z8.uuid()
+});
+var exerciseTranslationGenerationQueueMessageSchema = z8.object({
+  userId: z8.uuid(),
+  organizationId: z8.uuid(),
+  exerciseId: z8.uuid(),
+  jobId: z8.uuid(),
+  languages: z8.array(z8.enum(translationLanguages)).min(1)
 }).refine((value) => new Set(value.languages).size === value.languages.length, {
   message: "languages must be unique"
 });
-var exerciseSheetTranslationGenerationQueueMessageSchema = z5.object({
-  userId: z5.uuid(),
-  organizationId: z5.uuid(),
-  exerciseSheetId: z5.uuid(),
-  jobId: z5.uuid(),
-  language: z5.enum(translationLanguages),
-  sourceLanguage: z5.enum(translationLanguages).optional()
-});
-var exerciseImportQueueMessageSchema = z5.object({
-  source: z5.literal("ui"),
-  userId: z5.uuid(),
-  organizationId: z5.uuid(),
-  files: z5.array(importFileSchema),
-  exerciseSheetId: z5.uuid().nullable().optional(),
-  jobId: z5.string(),
-  docxGotenbergConversionEnabled: z5.boolean().optional(),
-  translateToLanguages: z5.array(z5.enum(translationLanguages)).refine((languages) => new Set(languages).size === languages.length, {
+var exerciseSheetTranslationGenerationQueueMessageSchema = z8.object({
+  userId: z8.uuid(),
+  organizationId: z8.uuid(),
+  exerciseSheetId: z8.uuid(),
+  jobId: z8.uuid(),
+  language: z8.enum(translationLanguages),
+  sourceLanguage: z8.enum(translationLanguages).optional()
+});
+var exerciseImportQueueMessageSchema = z8.object({
+  source: z8.literal("ui"),
+  userId: z8.uuid(),
+  organizationId: z8.uuid(),
+  files: z8.array(importFileSchema),
+  exerciseSheetId: z8.uuid().nullable().optional(),
+  jobId: z8.string(),
+  docxGotenbergConversionEnabled: z8.boolean().optional(),
+  translateToLanguages: z8.array(z8.enum(translationLanguages)).refine((languages) => new Set(languages).size === languages.length, {
     message: "translateToLanguages must be unique"
   }).optional()
 });
-var exerciseEmbeddingRecalculationQueueMessageSchema = z5.object({
-  exerciseId: z5.uuid(),
-  force: z5.boolean().optional()
+var exerciseEmbeddingRecalculationQueueMessageSchema = z8.object({
+  exerciseId: z8.uuid(),
+  force: z8.boolean().optional()
 });
-var externalNotificationQueueMessageSchema = z5.discriminatedUnion("type", [
-  z5.object({
-    type: z5.literal("new_user_signup"),
-    userId: z5.uuid(),
-    email: z5.email().nullable(),
-    occurredAt: z5.iso.datetime({ offset: true })
+var externalNotificationQueueMessageSchema = z8.discriminatedUnion("type", [
+  z8.object({
+    type: z8.literal("new_user_signup"),
+    userId: z8.uuid(),
+    email: z8.email().nullable(),
+    occurredAt: z8.iso.datetime({ offset: true })
   })
 ]);
 
 // ../shared/src/templates/export-template-definitions.ts
-import { z as z6 } from "zod";
+import { z as z9 } from "zod";
 var showScoresParameterSchema = {
-  showScores: z6.boolean().default(true)
+  showScores: z9.boolean().default(true)
 };
 var showScoresParameterUi = {
   showScores: {
@@ -2089,11 +3756,11 @@ var showScoresParameterUi = {
     shouldDisplay: ({ scoringEnabled }) => scoringEnabled
   }
 };
-var baseExportTemplateParametersSchema = z6.object(showScoresParameterSchema).strict();
+var baseExportTemplateParametersSchema = z9.object(showScoresParameterSchema).strict();
 var workspaceHeightParameterConfig = {
-  defaultValue: 4,
-  min: 0,
-  max: 12,
+  defaultValue: worksheetPreviewLayoutSettingsLimits.workspaceHeightInCm.default,
+  min: worksheetPreviewLayoutSettingsLimits.workspaceHeightInCm.min,
+  max: worksheetPreviewLayoutSettingsLimits.workspaceHeightInCm.max,
   step: 0.5
 };
 var exportTemplateDefinitions = {
@@ -2104,9 +3771,10 @@ var exportTemplateDefinitions = {
   },
   "exercises-with-workspace": {
     id: "exercises-with-workspace",
-    parametersSchema: z6.object({
+    parametersSchema: z9.object({
       ...showScoresParameterSchema,
-      workspaceHeightInCm: z6.number().min(workspaceHeightParameterConfig.min).max(workspaceHeightParameterConfig.max).default(workspaceHeightParameterConfig.defaultValue)
+      workspaceHeightInCm: z9.number().min(workspaceHeightParameterConfig.min).max(workspaceHeightParameterConfig.max).default(workspaceHeightParameterConfig.defaultValue),
+      workspaceFillMode: z9.enum(worksheetWorkspaceFillModes).default("grid")
     }).strict(),
     parameterUi: {
       ...showScoresParameterUi,
@@ -2116,6 +3784,11 @@ var exportTemplateDefinitions = {
         max: workspaceHeightParameterConfig.max,
         step: workspaceHeightParameterConfig.step,
         unit: "cm"
+      },
+      workspaceFillMode: {
+        control: "select",
+        options: [...worksheetWorkspaceFillModes],
+        shouldDisplay: ({ previewRendererMode }) => previewRendererMode === "html"
       }
     }
   },
@@ -2157,6 +3830,20 @@ var parseUpdateExerciseAgentInput = (input) => {
   }
   return parsedInput.data;
 };
+var parseCreateExerciseAgentInput = (input) => {
+  const parsedInput = createExerciseAgentInputSchema.safeParse(input);
+  if (!parsedInput.success) {
+    throw new CliCommandError(`Invalid exercise create input: ${formatZodIssues(parsedInput.error.issues)}`, 2);
+  }
+  return parsedInput.data;
+};
+var parseCreateSheetAgentInput = (input) => {
+  const parsedInput = createSheetAgentInputSchema.safeParse(input);
+  if (!parsedInput.success) {
+    throw new CliCommandError(`Invalid sheet create input: ${formatZodIssues(parsedInput.error.issues)}`, 2);
+  }
+  return parsedInput.data;
+};
 var parseUpdateSheetAgentInput = (input) => {
   const parsedInput = updateSheetAgentInputSchema.safeParse(input);
   if (!parsedInput.success) {
@@ -2459,7 +4146,7 @@ var formatCliImportTranslationJobs = (translationJobs) => {
 // src/lib/manifest.ts
 import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
 import { resolve as resolve2 } from "node:path";
-import { z as z7 } from "zod";
+import { z as z10 } from "zod";
 
 // src/lib/translation-languages.ts
 var translationLanguages2 = ["english", "hungarian", "german", "french", "spanish", "italian"];
@@ -2489,7 +4176,7 @@ var normalizeOptionalString4 = (value) => {
   const normalizedValue = value.trim();
   return normalizedValue.length > 0 ? normalizedValue : void 0;
 };
-var translationLanguageListSchema = z7.array(z7.enum(translationLanguages2)).min(1, { message: "translateTo must include at least one language." }).refine((languages) => new Set(languages).size === languages.length, {
+var translationLanguageListSchema = z10.array(z10.enum(translationLanguages2)).min(1, { message: "translateTo must include at least one language." }).refine((languages) => new Set(languages).size === languages.length, {
   message: "translateTo languages must be unique."
 });
 var sheetImportComponentIdPattern2 = /^[a-zA-Z0-9_-]{1,80}$/;
@@ -3272,6 +4959,46 @@ var throwSilentExitCode = (exitCode) => {
   throw new CliCommandError("", exitCode, false);
 };
 
+// src/commands/exercise-labels.ts
+var formatExerciseLabelsOutput = ({ labels }) => {
+  if (labels.length === 0) {
+    return "No exercise labels returned.";
+  }
+  return [
+    `${labels.length} exercise label${labels.length === 1 ? "" : "s"} returned.`,
+    ...labels.map((label) => `${"  ".repeat(label.depth)}${label.id}  ${label.displayPath}`)
+  ].join("\n");
+};
+var createExerciseLabelsCommand = (context) => ({
+  command: "labels",
+  describe: "List canonical exercise labels supported by ChalkSurf",
+  builder: (labelsYargs) => labelsYargs.example("chalksurf exercise labels --json", "List valid exercise labels for agent workflows"),
+  handler: async (argv) => {
+    const { apiClient, organizationId } = await createResolvedApiClient({
+      context,
+      baseUrlFlagValue: argv.baseUrl,
+      organizationFlagValue: argv.organization,
+      profileName: argv.profile
+    });
+    let result;
+    try {
+      result = await apiClient.agentListExerciseLabels();
+    } catch (error) {
+      throw mapApiErrorToCliError(error);
+    }
+    context.output.print(
+      {
+        organizationId: organizationId ?? null,
+        labels: result.labels
+      },
+      (output) => formatExerciseLabelsOutput({ labels: output.labels }),
+      {
+        command: "exercise labels"
+      }
+    );
+  }
+});
+
 // src/commands/exercise.ts
 var exerciseStatusOptions2 = ["verified", "unverified", "invalid"];
 var noSearchableTermsWarningMessage = "Search terms were too common and were ignored.";
@@ -3314,9 +5041,27 @@ var formatExerciseDetailsOutput = ({ exercise }) => {
 var formatCopyExerciseOutput = ({ receipt }) => {
   return formatAgentWriteReceiptOutput({ receipt });
 };
+var formatCreateExerciseOutput = ({ receipt }) => {
+  return formatAgentWriteReceiptOutput({ receipt });
+};
+var formatDeleteExerciseOutput = ({ receipt }) => {
+  return formatAgentWriteReceiptOutput({ receipt });
+};
 var formatUpdateExerciseOutput = ({ receipt }) => {
   return formatAgentWriteReceiptOutput({ receipt });
 };
+var formatSetExerciseVisibilityOutput = ({ receipt }) => {
+  return formatAgentWriteReceiptOutput({ receipt });
+};
+var resolveVisibilityFlag = ({ privateFlag, publicFlag }) => {
+  if (publicFlag && privateFlag) {
+    throw new CliCommandError("--public and --private cannot be used together.", 2);
+  }
+  if (!publicFlag && !privateFlag) {
+    throw new CliCommandError("Either --public or --private is required.", 2);
+  }
+  return Boolean(publicFlag);
+};
 var formatExerciseUsageOutput = ({ usage }) => {
   const sheetCount = usage.sheets.length;
   const otherSheetCount = usage.otherOrganizationSheetCount;
@@ -3386,7 +5131,7 @@ var resolveRequestedUuid = ({
     }
     return void 0;
   }
-  const parsedValue = z8.uuid().safeParse(resolvedValue);
+  const parsedValue = z11.uuid().safeParse(resolvedValue);
   if (!parsedValue.success) {
     throw new CliCommandError(`${label} must be a valid UUID.`, 2);
   }
@@ -3470,7 +5215,7 @@ var formatWaitedImportOutput = (job) => {
   return `${job.jobId} ${job.status ?? "pending"}`;
 };
 var registerExerciseCommands = (exerciseYargs, context) => {
-  return exerciseYargs.command(
+  return exerciseYargs.command(createExerciseLabelsCommand(context)).command(
     "search",
     "Search exercises visible to the selected organization",
     (searchYargs) => searchYargs.option("text", {
@@ -3519,7 +5264,7 @@ var registerExerciseCommands = (exerciseYargs, context) => {
       'chalksurf exercise search --text "binomial theorem" --language english --ownership own --json',
       "Verify imported exercises in the selected organization"
     ).example(
-      "chalksurf --profile prod-codex exercise search --label geometry.triangles --status unverified --json",
+      "chalksurf --profile prod-codex exercise search --label geometry.triangle --status unverified --json",
       "Find agent-created exercises that still need review"
     ),
     async (argv) => {
@@ -3735,6 +5480,107 @@ var registerExerciseCommands = (exerciseYargs, context) => {
         }
       );
     }
+  ).command(
+    "create",
+    "Create an exercise from an agent JSON payload",
+    (createYargs) => createYargs.option("input-json", {
+      type: "string",
+      demandOption: true,
+      describe: "JSON object matching the agent exercise create contract"
+    }).example(
+      `chalksurf exercise create --input-json '{"translations":{"english":{"exercise_text":"Find $x$."}},"labels":["algebra.equations"]}' --json`,
+      "Create an exercise for an agent workflow"
+    ),
+    async (argv) => {
+      const input = parseCreateExerciseAgentInput(
+        parseJsonObjectFlag({ label: "--input-json", value: argv.inputJson })
+      );
+      const { apiClient, organizationId } = await createResolvedApiClient({
+        context,
+        baseUrlFlagValue: argv.baseUrl,
+        organizationFlagValue: argv.organization,
+        profileName: argv.profile
+      });
+      let result;
+      try {
+        result = await apiClient.agentCreateExercise(input);
+      } catch (error) {
+        throw mapApiErrorToCliError(error);
+      }
+      context.output.print(
+        {
+          request: {
+            ...input,
+            organizationId: organizationId ?? null
+          },
+          receipt: result.receipt
+        },
+        (output) => formatCreateExerciseOutput({ receipt: output.receipt }),
+        {
+          command: "exercise create"
+        }
+      );
+    }
+  ).command(
+    "delete [exerciseId]",
+    "Delete an unused exercise after confirmation",
+    (deleteYargs) => deleteYargs.positional("exerciseId", {
+      type: "string",
+      describe: "Exercise ID to delete"
+    }).option("expected-updated-at", {
+      type: "string",
+      demandOption: true,
+      describe: "Expected current exercise updated_at ISO timestamp"
+    }).option("confirm-resource-id", {
+      type: "string",
+      demandOption: true,
+      describe: "Must exactly match the exercise ID being deleted"
+    }).example(
+      "chalksurf exercise delete 00000000-0000-4000-8000-000000000001 --expected-updated-at 2026-01-01T00:00:00.000Z --confirm-resource-id 00000000-0000-4000-8000-000000000001 --json",
+      "Delete an unused exercise with destructive confirmation"
+    ),
+    async (argv) => {
+      const id = resolveRequestedUuid({
+        fallbackValue: argv.exerciseId,
+        label: "exerciseId",
+        required: true
+      });
+      const confirmResourceId = resolveRequestedUuid({
+        flagValue: argv.confirmResourceId,
+        label: "--confirm-resource-id",
+        required: true
+      });
+      const input = {
+        id,
+        expectedUpdatedAt: argv.expectedUpdatedAt,
+        confirmResourceId
+      };
+      const { apiClient, organizationId } = await createResolvedApiClient({
+        context,
+        baseUrlFlagValue: argv.baseUrl,
+        organizationFlagValue: argv.organization,
+        profileName: argv.profile
+      });
+      let result;
+      try {
+        result = await apiClient.agentDeleteExercise(input);
+      } catch (error) {
+        throw mapApiErrorToCliError(error);
+      }
+      context.output.print(
+        {
+          request: {
+            ...input,
+            organizationId: organizationId ?? null
+          },
+          receipt: result.receipt
+        },
+        (output) => formatDeleteExerciseOutput({ receipt: output.receipt }),
+        {
+          command: "exercise delete"
+        }
+      );
+    }
   ).command(
     "update [exerciseId]",
     "Apply a field-level patch to an exercise",
@@ -3804,6 +5650,75 @@ var registerExerciseCommands = (exerciseYargs, context) => {
         }
       );
     }
+  ).command(
+    "set-visibility [exerciseId]",
+    "Set exercise visibility after checking the current updated_at value",
+    (visibilityYargs) => visibilityYargs.positional("exerciseId", {
+      type: "string",
+      describe: "Exercise ID to update"
+    }).option("expected-updated-at", {
+      type: "string",
+      demandOption: true,
+      describe: "Expected current exercise updated_at ISO timestamp"
+    }).option("public", {
+      type: "boolean",
+      describe: "Make the exercise public"
+    }).option("private", {
+      type: "boolean",
+      describe: "Make the exercise private"
+    }).option("confirm-make-public-resource-id", {
+      type: "string",
+      describe: "Required when using --public; must exactly match the exercise ID"
+    }).example(
+      "chalksurf exercise set-visibility 00000000-0000-4000-8000-000000000001 --public --expected-updated-at 2026-01-01T00:00:00.000Z --confirm-make-public-resource-id 00000000-0000-4000-8000-000000000001 --json",
+      "Make an exercise public with confirmation"
+    ),
+    async (argv) => {
+      const id = resolveRequestedUuid({
+        fallbackValue: argv.exerciseId,
+        label: "exerciseId",
+        required: true
+      });
+      const isPublic = resolveVisibilityFlag({
+        privateFlag: argv.private,
+        publicFlag: argv.public
+      });
+      const confirmMakePublicResourceId = resolveRequestedUuid({
+        flagValue: argv.confirmMakePublicResourceId,
+        label: "--confirm-make-public-resource-id"
+      });
+      const input = {
+        id,
+        expectedUpdatedAt: argv.expectedUpdatedAt,
+        isPublic,
+        ...confirmMakePublicResourceId === void 0 ? {} : { confirmMakePublicResourceId }
+      };
+      const { apiClient, organizationId } = await createResolvedApiClient({
+        context,
+        baseUrlFlagValue: argv.baseUrl,
+        organizationFlagValue: argv.organization,
+        profileName: argv.profile
+      });
+      let result;
+      try {
+        result = await apiClient.agentSetExerciseVisibility(input);
+      } catch (error) {
+        throw mapApiErrorToCliError(error);
+      }
+      context.output.print(
+        {
+          request: {
+            ...input,
+            organizationId: organizationId ?? null
+          },
+          receipt: result.receipt
+        },
+        (output) => formatSetExerciseVisibilityOutput({ receipt: output.receipt }),
+        {
+          command: "exercise set-visibility"
+        }
+      );
+    }
   ).command(
     "validate-latex",
     "Validate LaTeX snippets before updating exercise or sheet content",
@@ -4208,7 +6123,121 @@ var registerExerciseCommands = (exerciseYargs, context) => {
         await cleanupResolvedSources(resolvedSources);
       }
     }
-  ).demandCommand(1).strict();
+  ).demandCommand(1).strict();
+};
+
+// src/commands/feedback.ts
+var parseOptionalContextJson = (value) => {
+  return value === void 0 ? void 0 : parseJsonObjectFlag({ label: "--context-json", value });
+};
+var requireMessage = (value) => {
+  const message = value?.trim();
+  if (!message) {
+    throw new CliCommandError("--message is required.", 2);
+  }
+  return message;
+};
+var formatFeedbackOutput = ({ receipt }) => `Submitted ${receipt.eventType} feedback event ${receipt.eventId}.`;
+var registerFeedbackCommands = (feedbackYargs, context) => {
+  return feedbackYargs.command(
+    "user",
+    "Send user-consented feedback to ChalkSurf",
+    (userYargs) => userYargs.option("message", {
+      type: "string",
+      demandOption: true,
+      describe: "Feedback text the user agreed to send"
+    }).option("user-consent", {
+      type: "boolean",
+      default: false,
+      describe: "Confirm the user explicitly consented to sending this feedback"
+    }).option("category", {
+      type: "string",
+      choices: ["bug_report", "feature_request", "frustration", "blocked_request", "other"],
+      describe: "Feedback category"
+    }).option("context-json", {
+      type: "string",
+      describe: "Optional JSON object with reproduction details or request context"
+    }).example(
+      'chalksurf feedback user --message "Import failed for my sheet" --user-consent --json',
+      "Send user-consented feedback"
+    ),
+    async (argv) => {
+      if (!argv.userConsent) {
+        throw new CliCommandError("--user-consent is required before sending user feedback.", 2);
+      }
+      const input = {
+        message: requireMessage(argv.message),
+        userConsent: true,
+        ...argv.category ? { category: argv.category } : {},
+        ...argv.contextJson === void 0 ? {} : { context: parseOptionalContextJson(argv.contextJson) }
+      };
+      const { apiClient, organizationId } = await createResolvedApiClient({
+        context,
+        baseUrlFlagValue: argv.baseUrl,
+        organizationFlagValue: argv.organization,
+        profileName: argv.profile
+      });
+      let result;
+      try {
+        result = await apiClient.agentSendUserFeedback(input);
+      } catch (error) {
+        throw mapApiErrorToCliError(error);
+      }
+      context.output.print(
+        {
+          organizationId: organizationId ?? null,
+          receipt: result.receipt
+        },
+        (output) => formatFeedbackOutput({ receipt: output.receipt }),
+        { command: "feedback user" }
+      );
+    }
+  ).command(
+    "agent",
+    "Send agent-observed CLI, MCP, API, or documentation feedback to ChalkSurf",
+    (agentYargs) => agentYargs.option("message", {
+      type: "string",
+      demandOption: true,
+      describe: "Feedback text describing the agent-observed issue"
+    }).option("category", {
+      type: "string",
+      choices: ["api_inconsistency", "documentation_issue", "missing_capability", "unexpected_behavior", "other"],
+      describe: "Feedback category"
+    }).option("context-json", {
+      type: "string",
+      describe: "Optional JSON object with command, tool, or documentation context"
+    }).example(
+      'chalksurf feedback agent --message "MCP tool output differed from docs" --category documentation_issue --json',
+      "Send agent-observed feedback"
+    ),
+    async (argv) => {
+      const input = {
+        message: requireMessage(argv.message),
+        ...argv.category ? { category: argv.category } : {},
+        ...argv.contextJson === void 0 ? {} : { context: parseOptionalContextJson(argv.contextJson) }
+      };
+      const { apiClient, organizationId } = await createResolvedApiClient({
+        context,
+        baseUrlFlagValue: argv.baseUrl,
+        organizationFlagValue: argv.organization,
+        profileName: argv.profile
+      });
+      let result;
+      try {
+        result = await apiClient.agentSendAgentFeedback(input);
+      } catch (error) {
+        throw mapApiErrorToCliError(error);
+      }
+      context.output.print(
+        {
+          organizationId: organizationId ?? null,
+          receipt: result.receipt
+        },
+        (output) => formatFeedbackOutput({ receipt: output.receipt }),
+        { command: "feedback agent" }
+      );
+    }
+  ).demandCommand(1);
 };
 
 // src/commands/job.ts
@@ -4631,7 +6660,7 @@ var registerProfileCommands = (profileYargs, context) => {
 };
 
 // src/commands/sheet.ts
-import { z as z9 } from "zod";
+import { z as z12 } from "zod";
 var readinessIssueTypeLabels = {
   missing_translation: "missing translations",
   missing_solution: "missing solutions",
@@ -4755,7 +6784,7 @@ var resolveRequestedUuid2 = ({
     }
     return void 0;
   }
-  const parsedValue = z9.uuid().safeParse(resolvedValue);
+  const parsedValue = z12.uuid().safeParse(resolvedValue);
   if (!parsedValue.success) {
     throw new CliCommandError(`${label} must be a valid UUID.`, 2);
   }
@@ -4766,7 +6795,7 @@ var resolveRequestedUuidList = ({ label, values }) => {
     throw new CliCommandError(`${label} is required at least once.`, 2);
   }
   return values.map((value, index) => {
-    const parsedValue = z9.uuid().safeParse(value.trim());
+    const parsedValue = z12.uuid().safeParse(value.trim());
     if (!parsedValue.success) {
       throw new CliCommandError(`${label}[${index}] must be a valid UUID.`, 2);
     }
@@ -5102,6 +7131,33 @@ var formatSheetDetailsOutput = ({ sheet }) => {
     `readiness: ${formatSheetReadinessSummary(sheet.readinessSummary)}`
   ].join("\n");
 };
+var formatSheetVersionListOutput = ({ versions }) => {
+  if (versions.length === 0) {
+    return "No sheet versions found.";
+  }
+  return [
+    `${versions.length} sheet version${versions.length === 1 ? "" : "s"} returned.`,
+    ...versions.map(
+      (version) => [
+        version.id,
+        `v${version.versionNumber}`,
+        version.type,
+        version.createdAt,
+        version.createdByName ? `by ${version.createdByName}` : null,
+        version.sourceVersionId ? `source: ${version.sourceVersionId}` : null
+      ].filter(Boolean).join("  ")
+    )
+  ].join("\n");
+};
+var formatSheetVersionDetailsOutput = ({ version }) => {
+  return [
+    `Sheet version ${version.id}`,
+    `sheet: ${version.exerciseSheetId}`,
+    `version: ${version.versionNumber}`,
+    `type: ${version.type}`,
+    `exercises: ${version.exercises.length}`
+  ].join("\n");
+};
 var formatSheetIssuesOutput = ({ issues, readinessSummary }) => {
   if (issues.length === 0) {
     return `No sheet issues found. ${formatSheetReadinessSummary(readinessSummary)}`;
@@ -5126,9 +7182,18 @@ var formatSheetIssuesOutput = ({ issues, readinessSummary }) => {
 var formatCopySheetOutput = ({ receipt }) => {
   return formatAgentWriteReceiptOutput({ receipt });
 };
+var formatCreateSheetOutput = ({ receipt }) => {
+  return formatAgentWriteReceiptOutput({ receipt });
+};
+var formatDeleteSheetOutput = ({ receipt }) => {
+  return formatAgentWriteReceiptOutput({ receipt });
+};
 var formatUpdateSheetOutput = ({ receipt }) => {
   return formatAgentWriteReceiptOutput({ receipt });
 };
+var formatSetSheetVisibilityOutput = ({ receipt }) => {
+  return formatAgentWriteReceiptOutput({ receipt });
+};
 var formatAppendExercisesToSheetOutput = ({ receipt }) => {
   return formatAgentWriteReceiptOutput({ receipt });
 };
@@ -5144,9 +7209,21 @@ var formatFolderListOutput = ({ folders }) => {
 var formatCreateFolderOutput = ({ receipt }) => {
   return formatAgentWriteReceiptOutput({ receipt });
 };
+var formatDeleteFolderOutput = ({ receipt }) => {
+  return formatAgentWriteReceiptOutput({ receipt });
+};
 var formatRenameFolderOutput = ({ receipt }) => {
   return formatAgentWriteReceiptOutput({ receipt });
 };
+var resolveVisibilityFlag2 = ({ privateFlag, publicFlag }) => {
+  if (publicFlag && privateFlag) {
+    throw new CliCommandError("--public and --private cannot be used together.", 2);
+  }
+  if (!publicFlag && !privateFlag) {
+    throw new CliCommandError("Either --public or --private is required.", 2);
+  }
+  return Boolean(publicFlag);
+};
 var registerSheetCommands = (sheetYargs, context) => {
   return sheetYargs.command(
     "search",
@@ -5279,6 +7356,99 @@ var registerSheetCommands = (sheetYargs, context) => {
         }
       );
     }
+  ).command(
+    "versions [exerciseSheetId]",
+    "List version history for an exercise sheet owned by the selected organization",
+    (versionsYargs) => versionsYargs.positional("exerciseSheetId", {
+      type: "string",
+      describe: "Exercise sheet ID to inspect"
+    }).example(
+      "chalksurf sheet versions 00000000-0000-4000-8000-000000000001 --json",
+      "List restorable sheet versions for an agent audit"
+    ),
+    async (argv) => {
+      const id = resolveRequestedUuid2({
+        fallbackValue: argv.exerciseSheetId,
+        label: "exerciseSheetId",
+        required: true
+      });
+      const { apiClient, organizationId } = await createResolvedApiClient({
+        context,
+        baseUrlFlagValue: argv.baseUrl,
+        organizationFlagValue: argv.organization,
+        profileName: argv.profile
+      });
+      let result;
+      try {
+        result = await apiClient.agentListSheetVersions(id);
+      } catch (error) {
+        throw mapApiErrorToCliError(error);
+      }
+      context.output.print(
+        {
+          request: {
+            id,
+            organizationId: organizationId ?? null
+          },
+          versions: result.versions
+        },
+        (output) => formatSheetVersionListOutput({ versions: output.versions }),
+        {
+          command: "sheet versions"
+        }
+      );
+    }
+  ).command(
+    "version [exerciseSheetId] [versionId]",
+    "Get one exercise sheet version snapshot",
+    (versionYargs) => versionYargs.positional("exerciseSheetId", {
+      type: "string",
+      describe: "Exercise sheet ID to inspect"
+    }).positional("versionId", {
+      type: "string",
+      describe: "Sheet version ID to fetch"
+    }).example(
+      "chalksurf sheet version 00000000-0000-4000-8000-000000000001 00000000-0000-4000-8000-000000000002 --json",
+      "Fetch one sheet version snapshot for an agent audit"
+    ),
+    async (argv) => {
+      const exerciseSheetId = resolveRequestedUuid2({
+        fallbackValue: argv.exerciseSheetId,
+        label: "exerciseSheetId",
+        required: true
+      });
+      const versionId = resolveRequestedUuid2({
+        fallbackValue: argv.versionId,
+        label: "versionId",
+        required: true
+      });
+      const { apiClient, organizationId } = await createResolvedApiClient({
+        context,
+        baseUrlFlagValue: argv.baseUrl,
+        organizationFlagValue: argv.organization,
+        profileName: argv.profile
+      });
+      let result;
+      try {
+        result = await apiClient.agentGetSheetVersion(exerciseSheetId, versionId);
+      } catch (error) {
+        throw mapApiErrorToCliError(error);
+      }
+      context.output.print(
+        {
+          request: {
+            exerciseSheetId,
+            versionId,
+            organizationId: organizationId ?? null
+          },
+          version: result.version
+        },
+        (output) => formatSheetVersionDetailsOutput({ version: output.version }),
+        {
+          command: "sheet version"
+        }
+      );
+    }
   ).command(
     "issues [exerciseSheetId]",
     "List actionable issues for an exercise sheet",
@@ -5404,6 +7574,58 @@ var registerSheetCommands = (sheetYargs, context) => {
           }
         );
       }
+    ).command(
+      "delete [folderId]",
+      "Delete an empty folder after confirmation",
+      (deleteYargs) => deleteYargs.positional("folderId", {
+        type: "string",
+        describe: "Folder ID to delete"
+      }).option("confirm-resource-id", {
+        type: "string",
+        demandOption: true,
+        describe: "Must exactly match the folder ID being deleted"
+      }).example(
+        "chalksurf sheet folder delete 00000000-0000-4000-8000-000000000001 --confirm-resource-id 00000000-0000-4000-8000-000000000001 --json",
+        "Delete an empty folder with destructive confirmation"
+      ),
+      async (argv) => {
+        const id = resolveRequestedUuid2({
+          fallbackValue: argv.folderId,
+          label: "folderId",
+          required: true
+        });
+        const confirmResourceId = resolveRequestedUuid2({
+          flagValue: argv.confirmResourceId,
+          label: "--confirm-resource-id",
+          required: true
+        });
+        const input = { id, confirmResourceId };
+        const { apiClient, organizationId } = await createResolvedApiClient({
+          context,
+          baseUrlFlagValue: argv.baseUrl,
+          organizationFlagValue: argv.organization,
+          profileName: argv.profile
+        });
+        let result;
+        try {
+          result = await apiClient.agentDeleteFolder(input);
+        } catch (error) {
+          throw mapApiErrorToCliError(error);
+        }
+        context.output.print(
+          {
+            request: {
+              ...input,
+              organizationId: organizationId ?? null
+            },
+            receipt: result.receipt
+          },
+          (output) => formatDeleteFolderOutput({ receipt: output.receipt }),
+          {
+            command: "sheet folder delete"
+          }
+        );
+      }
     ).command(
       "rename [folderId] [name]",
       "Rename a folder in the selected organization",
@@ -5454,6 +7676,176 @@ var registerSheetCommands = (sheetYargs, context) => {
     ).demandCommand(1),
     () => {
     }
+  ).command(
+    "create",
+    "Create an exercise sheet from an agent JSON payload",
+    (createYargs) => createYargs.option("input-json", {
+      type: "string",
+      demandOption: true,
+      describe: "JSON object matching the agent sheet create contract"
+    }).example(
+      `chalksurf sheet create --input-json '{"name":"Practice","language":"english","exerciseIds":["00000000-0000-4000-8000-000000000001"]}' --json`,
+      "Create a sheet for an agent workflow"
+    ),
+    async (argv) => {
+      const input = parseCreateSheetAgentInput(
+        parseJsonObjectFlag({ label: "--input-json", value: argv.inputJson })
+      );
+      const { apiClient, organizationId } = await createResolvedApiClient({
+        context,
+        baseUrlFlagValue: argv.baseUrl,
+        organizationFlagValue: argv.organization,
+        profileName: argv.profile
+      });
+      let result;
+      try {
+        result = await apiClient.agentCreateSheet(input);
+      } catch (error) {
+        throw mapApiErrorToCliError(error);
+      }
+      context.output.print(
+        {
+          request: {
+            ...input,
+            organizationId: organizationId ?? null
+          },
+          receipt: result.receipt
+        },
+        (output) => formatCreateSheetOutput({ receipt: output.receipt }),
+        {
+          command: "sheet create"
+        }
+      );
+    }
+  ).command(
+    "delete [exerciseSheetId]",
+    "Delete an exercise sheet after confirmation",
+    (deleteYargs) => deleteYargs.positional("exerciseSheetId", {
+      type: "string",
+      describe: "Exercise sheet ID to delete"
+    }).option("expected-updated-at", {
+      type: "string",
+      demandOption: true,
+      describe: "Expected current sheet updated_at ISO timestamp"
+    }).option("confirm-resource-id", {
+      type: "string",
+      demandOption: true,
+      describe: "Must exactly match the sheet ID being deleted"
+    }).example(
+      "chalksurf sheet delete 00000000-0000-4000-8000-000000000001 --expected-updated-at 2026-01-01T00:00:00.000Z --confirm-resource-id 00000000-0000-4000-8000-000000000001 --json",
+      "Delete a sheet with destructive confirmation"
+    ),
+    async (argv) => {
+      const id = resolveRequestedUuid2({
+        fallbackValue: argv.exerciseSheetId,
+        label: "exerciseSheetId",
+        required: true
+      });
+      const confirmResourceId = resolveRequestedUuid2({
+        flagValue: argv.confirmResourceId,
+        label: "--confirm-resource-id",
+        required: true
+      });
+      const input = {
+        id,
+        expectedUpdatedAt: argv.expectedUpdatedAt,
+        confirmResourceId
+      };
+      const { apiClient, organizationId } = await createResolvedApiClient({
+        context,
+        baseUrlFlagValue: argv.baseUrl,
+        organizationFlagValue: argv.organization,
+        profileName: argv.profile
+      });
+      let result;
+      try {
+        result = await apiClient.agentDeleteSheet(input);
+      } catch (error) {
+        throw mapApiErrorToCliError(error);
+      }
+      context.output.print(
+        {
+          request: {
+            ...input,
+            organizationId: organizationId ?? null
+          },
+          receipt: result.receipt
+        },
+        (output) => formatDeleteSheetOutput({ receipt: output.receipt }),
+        {
+          command: "sheet delete"
+        }
+      );
+    }
+  ).command(
+    "set-visibility [exerciseSheetId]",
+    "Set sheet visibility after checking the current updated_at value",
+    (visibilityYargs) => visibilityYargs.positional("exerciseSheetId", {
+      type: "string",
+      describe: "Exercise sheet ID to update"
+    }).option("expected-updated-at", {
+      type: "string",
+      demandOption: true,
+      describe: "Expected current sheet updated_at ISO timestamp"
+    }).option("public", {
+      type: "boolean",
+      describe: "Make the sheet public"
+    }).option("private", {
+      type: "boolean",
+      describe: "Make the sheet private"
+    }).option("confirm-make-public-resource-id", {
+      type: "string",
+      describe: "Required when using --public; must exactly match the sheet ID"
+    }).example(
+      "chalksurf sheet set-visibility 00000000-0000-4000-8000-000000000001 --public --expected-updated-at 2026-01-01T00:00:00.000Z --confirm-make-public-resource-id 00000000-0000-4000-8000-000000000001 --json",
+      "Make a sheet public with confirmation"
+    ),
+    async (argv) => {
+      const id = resolveRequestedUuid2({
+        fallbackValue: argv.exerciseSheetId,
+        label: "exerciseSheetId",
+        required: true
+      });
+      const isPublic = resolveVisibilityFlag2({
+        privateFlag: argv.private,
+        publicFlag: argv.public
+      });
+      const confirmMakePublicResourceId = resolveRequestedUuid2({
+        flagValue: argv.confirmMakePublicResourceId,
+        label: "--confirm-make-public-resource-id"
+      });
+      const input = {
+        id,
+        expectedUpdatedAt: argv.expectedUpdatedAt,
+        isPublic,
+        ...confirmMakePublicResourceId === void 0 ? {} : { confirmMakePublicResourceId }
+      };
+      const { apiClient, organizationId } = await createResolvedApiClient({
+        context,
+        baseUrlFlagValue: argv.baseUrl,
+        organizationFlagValue: argv.organization,
+        profileName: argv.profile
+      });
+      let result;
+      try {
+        result = await apiClient.agentSetSheetVisibility(input);
+      } catch (error) {
+        throw mapApiErrorToCliError(error);
+      }
+      context.output.print(
+        {
+          request: {
+            ...input,
+            organizationId: organizationId ?? null
+          },
+          receipt: result.receipt
+        },
+        (output) => formatSetSheetVisibilityOutput({ receipt: output.receipt }),
+        {
+          command: "sheet set-visibility"
+        }
+      );
+    }
   ).command(
     "copy [exerciseSheetId] [name]",
     "Copy a visible exercise sheet into the selected organization",
@@ -6215,6 +8607,12 @@ var createCli = ({
     (exerciseYargs) => registerExerciseCommands(exerciseYargs, commandContext),
     () => {
     }
+  ).command(
+    "feedback <subcommand>",
+    "Feedback commands",
+    (feedbackYargs) => registerFeedbackCommands(feedbackYargs, commandContext),
+    () => {
+    }
   ).command(
     "sheet <subcommand>",
     "Exercise sheet commands",
@@ -6250,7 +8648,7 @@ var parseCliWithCapturedOutput = async ({
 var hasFlag = (argv, flags) => {
   return argv.some((argument) => flags.includes(argument));
 };
-var topLevelCommands = /* @__PURE__ */ new Set(["auth", "org", "profile", "exercise", "sheet", "job"]);
+var topLevelCommands = /* @__PURE__ */ new Set(["auth", "org", "profile", "exercise", "feedback", "sheet", "job"]);
 var hasTopLevelCommand = (argv) => {
   return argv.some((argument) => topLevelCommands.has(argument));
 };