@firfi/huly-mcp 0.15.0 → 0.16.0

package/README.md

@@ -406,9 +406,11 @@ For a Smithery publish schema example, see [docs/SMITHERY_URL_PUBLISH.md](docs/S
 | Tool | Description |
 |------|-------------|
 | `list_associations` | List Huly association definitions: class-level typed links that define which document classes may be related. Use this before create_relation to discover association IDs, source/target classes, and whether relation writes are supported. |
+| `create_association` | Idempotently create one Huly association definition between two non-system classes. Use sourceClass/targetClass with sourceRole/targetRole and cardinality; returns an existing identical association by default. |
+| `delete_association` | Idempotently delete one Huly association definition only when no concrete relations reference it. If relations exist, delete_relation must clean them up first; deleting an already-missing association is a successful no-op. |
 | `list_relations` | List concrete Huly relation instances under an association, optionally filtered by source and target documents. Requires at least one filter to avoid broad workspace scans. |
-| `create_relation` | Idempotently create one concrete relation between two resolved documents. Only succeeds for associations where list_associations reports canCreateRelation=true; otherwise it fails clearly. This build currently reports no generic associations as writable until a write allowlist is live-validated. |
-| `delete_relation` | Idempotently delete one concrete relation by relation ID or by exact association/source/target triple. Only succeeds for associations where list_associations reports canDeleteRelation=true; otherwise it fails clearly. This build currently reports no generic associations as writable until a write allowlist is live-validated. |
+| `create_relation` | Idempotently create one concrete relation between two resolved documents for a writable association. Enforces association endpoint classes, direction, duplicate handling, automation-only restrictions, and cardinality. |
+| `delete_relation` | Idempotently delete one concrete relation by relation ID or by exact association/source/target triple. Triple deletes use the same direction semantics as create_relation and fail if the selector is ambiguous. |
 
 ### Activity
 

package/dist/index.cjs

@@ -151353,12 +151353,305 @@ var InvalidContentTypeError = class extends Schema_exports.TaggedError()(
   }
 };
 
+// src/domain/schemas/generic-associations.ts
+var AssociationIdentifier = NonEmptyString2.pipe(Schema_exports.brand("AssociationIdentifier"));
+var AssociationName = NonEmptyString2.pipe(Schema_exports.brand("AssociationName"));
+var AssociationRoleName = NonEmptyString2.pipe(Schema_exports.brand("AssociationRoleName"));
+var RelationIdentifier = NonEmptyString2.pipe(Schema_exports.brand("RelationIdentifier"));
+var ListRelationsWarning = NonEmptyString2.pipe(Schema_exports.brand("ListRelationsWarning"));
+var CardinalityValues = [
+  "one-to-one",
+  "one-to-many",
+  "many-to-many"
+];
+var CardinalitySchema = Schema_exports.Literal(...CardinalityValues).annotations({
+  description: `Association cardinality: ${enumValuesDescription(CardinalityValues)}`
+});
+var RelationDirectionValues = ["source-to-target", "target-to-source", "either"];
+var RelationDirectionSchema = Schema_exports.Literal(...RelationDirectionValues);
+var DefaultRelationDirection = "source-to-target";
+var relationDirectionDescription = `Relation traversal direction: ${enumValuesDescription(RelationDirectionValues)}. Defaults to ${DefaultRelationDirection}.`;
+var RelationIfExistsSchema = Schema_exports.Literal("return_existing", "fail");
+var AssociationIfExistsSchema = Schema_exports.Literal("return_existing", "fail");
+var RawObjectLocatorSchema = Schema_exports.Struct({
+  kind: Schema_exports.Literal("raw"),
+  id: DocId.annotations({
+    description: "Raw Huly document _id"
+  }),
+  class: Schema_exports.optional(ObjectClassName.annotations({
+    description: "Raw Huly document class, such as tracker:class:Issue. Required unless the association side determines the expected class."
+  }))
+});
+var IssueObjectLocatorSchema = Schema_exports.Struct({
+  kind: Schema_exports.Literal("issue"),
+  issue: IssueIdentifier.annotations({
+    description: "Issue identifier, such as HULY-123, or a numeric issue number when project is also provided."
+  }),
+  project: Schema_exports.optional(ProjectIdentifier.annotations({
+    description: "Project identifier. Optional when issue already includes a project prefix like HULY-123."
+  }))
+});
+var DocumentObjectLocatorSchema = Schema_exports.Struct({
+  kind: Schema_exports.Literal("document"),
+  document: DocumentIdentifier.annotations({
+    description: "Document title or ID"
+  }),
+  teamspace: Schema_exports.optional(TeamspaceIdentifier.annotations({
+    description: "Teamspace name or ID. If omitted, document title matches must be unique across the workspace."
+  }))
+});
+var GenericObjectLocatorSchema = Schema_exports.Union(
+  RawObjectLocatorSchema,
+  IssueObjectLocatorSchema,
+  DocumentObjectLocatorSchema
+).annotations({
+  title: "GenericObjectLocator",
+  description: "Explicit locator for a Huly document endpoint. Use raw for known _id values, issue for tracker issues, or document for Huly documents. Card locators are intentionally not included until a robust card resolver is available."
+});
+var ResolvedObjectSummarySchema = Schema_exports.Struct({
+  id: DocId,
+  class: ObjectClassName,
+  display: NonEmptyString2,
+  locatorKind: Schema_exports.Literal("raw", "issue", "document"),
+  warning: Schema_exports.optional(Schema_exports.String)
+});
+var AssociationSummarySchema = Schema_exports.Struct({
+  associationId: AssociationId,
+  name: Schema_exports.optional(AssociationName),
+  label: Schema_exports.optional(NonEmptyString2),
+  description: Schema_exports.optional(Schema_exports.String),
+  sourceClass: ObjectClassName,
+  sourceClassLabel: Schema_exports.optional(NonEmptyString2.annotations({
+    description: "Best-effort human display label for sourceClass when the class is known to this server"
+  })),
+  targetClass: ObjectClassName,
+  targetClassLabel: Schema_exports.optional(NonEmptyString2.annotations({
+    description: "Best-effort human display label for targetClass when the class is known to this server"
+  })),
+  sourceRole: Schema_exports.optional(AssociationRoleName),
+  targetRole: Schema_exports.optional(AssociationRoleName),
+  relationClass: Schema_exports.optional(ObjectClassName),
+  cardinality: CardinalitySchema,
+  symmetric: Schema_exports.Boolean,
+  system: Schema_exports.Boolean,
+  canListRelations: Schema_exports.Boolean,
+  canCreateRelation: Schema_exports.Boolean,
+  canDeleteRelation: Schema_exports.Boolean,
+  unsupportedReason: Schema_exports.optional(Schema_exports.String)
+});
+var RelationSummarySchema = Schema_exports.Struct({
+  relationId: RelationId,
+  associationId: AssociationId,
+  associationName: Schema_exports.optional(AssociationName),
+  source: ResolvedObjectSummarySchema,
+  target: ResolvedObjectSummarySchema,
+  createdOn: Schema_exports.optional(Timestamp),
+  modifiedOn: Schema_exports.optional(Timestamp)
+});
+var ListAssociationsParamsSchema = Schema_exports.Struct({
+  association: Schema_exports.optional(AssociationIdentifier.annotations({
+    description: "Association _id, source/target role name, or stable association name"
+  })),
+  sourceClass: Schema_exports.optional(ObjectClassName.annotations({
+    description: "Only return associations whose source class matches this Huly class ID"
+  })),
+  targetClass: Schema_exports.optional(ObjectClassName.annotations({
+    description: "Only return associations whose target class matches this Huly class ID"
+  })),
+  writableOnly: Schema_exports.optional(Schema_exports.Boolean.annotations({
+    description: "Only return associations whose relation create/delete path has been validated and allowlisted"
+  })),
+  includeSystem: Schema_exports.optional(Schema_exports.Boolean.annotations({
+    description: "Include internal/system associations. Defaults to false."
+  })),
+  limit: Schema_exports.optional(LimitParam.annotations({
+    description: "Maximum number of associations to return (default: 50)"
+  }))
+}).annotations({
+  title: "ListAssociationsParams",
+  description: "Parameters for listing generic Huly association definitions"
+});
+var ListAssociationsResultSchema = Schema_exports.Struct({
+  associations: Schema_exports.Array(AssociationSummarySchema),
+  total: Schema_exports.Number
+});
+var CreateAssociationParamsSchema = Schema_exports.Struct({
+  sourceClass: ObjectClassName.annotations({
+    description: "Source Huly class ID, such as tracker:class:Issue. core:class:* system classes are rejected."
+  }),
+  targetClass: ObjectClassName.annotations({
+    description: "Target Huly class ID, such as tracker:class:Issue. core:class:* system classes are rejected."
+  }),
+  sourceRole: AssociationRoleName.annotations({
+    description: "Role name stored on the source side of the association."
+  }),
+  targetRole: AssociationRoleName.annotations({
+    description: "Role name stored on the target side of the association."
+  }),
+  cardinality: CardinalitySchema,
+  automationOnly: Schema_exports.optional(Schema_exports.Boolean.annotations({
+    description: "Whether Huly automation-only UI paths should own relation writes for this association. Defaults to false."
+  })),
+  ifExists: Schema_exports.optional(AssociationIfExistsSchema.annotations({
+    description: "return_existing (default) returns an identical existing association; fail reports an existing association as an error"
+  }))
+}).annotations({
+  title: "CreateAssociationParams",
+  description: "Parameters for idempotently creating a Huly association definition in the model space. The created association can then be used with create_relation."
+});
+var CreateAssociationResultSchema = Schema_exports.Struct({
+  association: AssociationSummarySchema,
+  created: Schema_exports.Boolean,
+  existing: Schema_exports.Boolean
+});
+var DeleteAssociationParamsSchema = Schema_exports.Struct({
+  association: AssociationIdentifier.annotations({
+    description: "Association _id or unambiguous name returned by list_associations. Deleting a missing association is a successful no-op."
+  })
+}).annotations({
+  title: "DeleteAssociationParams",
+  description: "Parameters for idempotently deleting a Huly association definition. The association must have zero concrete relations."
+});
+var DeleteAssociationResultSchema = Schema_exports.Struct({
+  association: AssociationIdentifier,
+  associationId: Schema_exports.optional(AssociationId),
+  deleted: Schema_exports.Boolean,
+  relationCount: Schema_exports.Number,
+  reason: Schema_exports.optional(Schema_exports.Literal("not_found", "deleted"))
+});
+var ListRelationsParamsBaseSchema = Schema_exports.Struct({
+  association: Schema_exports.optional(AssociationIdentifier.annotations({
+    description: "Association _id or name. If omitted, relations are listed only across supported visible associations."
+  })),
+  source: Schema_exports.optional(GenericObjectLocatorSchema.annotations({
+    description: "Optional source endpoint filter"
+  })),
+  target: Schema_exports.optional(GenericObjectLocatorSchema.annotations({
+    description: "Optional target endpoint filter"
+  })),
+  direction: Schema_exports.optional(RelationDirectionSchema.annotations({
+    description: relationDirectionDescription
+  })),
+  limit: Schema_exports.optional(LimitParam.annotations({
+    description: "Maximum number of relations to return (default: 50)"
+  }))
+}).annotations({
+  title: "ListRelationsParams",
+  description: "Parameters for listing concrete Huly relation instances"
+});
+var ListRelationsParamsSchema = ListRelationsParamsBaseSchema.pipe(
+  Schema_exports.filter(
+    (params) => params.association === void 0 && params.source === void 0 && params.target === void 0 ? "Provide at least one of association, source, or target to avoid broad workspace scans." : void 0
+  )
+).annotations({
+  title: "ListRelationsParams",
+  description: "Parameters for listing concrete Huly relation instances"
+});
+var ListRelationsResultSchema = Schema_exports.Struct({
+  relations: Schema_exports.Array(RelationSummarySchema),
+  total: Schema_exports.Number,
+  warnings: Schema_exports.optional(
+    Schema_exports.NonEmptyArray(ListRelationsWarning).annotations({
+      description: "Non-fatal warnings about result completeness or resolution. Treat these as guidance for narrowing a follow-up call."
+    })
+  )
+});
+var CreateRelationParamsSchema = Schema_exports.Struct({
+  association: AssociationIdentifier.annotations({
+    description: "Association _id or unambiguous name returned by list_associations"
+  }),
+  source: GenericObjectLocatorSchema.annotations({
+    description: "Source endpoint document"
+  }),
+  target: GenericObjectLocatorSchema.annotations({
+    description: "Target endpoint document"
+  }),
+  direction: Schema_exports.optional(RelationDirectionSchema.annotations({
+    description: relationDirectionDescription
+  })),
+  ifExists: Schema_exports.optional(RelationIfExistsSchema.annotations({
+    description: "return_existing (default) returns an existing relation; fail reports an existing relation as an error"
+  }))
+}).annotations({
+  title: "CreateRelationParams",
+  description: "Parameters for idempotently creating a concrete generic relation"
+});
+var CreateRelationResultSchema = Schema_exports.Struct({
+  relationId: RelationId,
+  associationId: AssociationId,
+  source: ResolvedObjectSummarySchema,
+  target: ResolvedObjectSummarySchema,
+  created: Schema_exports.Boolean,
+  existing: Schema_exports.Boolean
+});
+var DeleteRelationByIdParamsSchema = Schema_exports.Struct({
+  relation: RelationIdentifier.annotations({
+    description: "Concrete relation _id to delete"
+  })
+}).annotations({
+  title: "DeleteRelationByIdParams",
+  description: "Delete one concrete relation by its relation ID."
+});
+var DeleteRelationByTripleParamsSchema = Schema_exports.Struct({
+  association: AssociationIdentifier.annotations({
+    description: "Association _id or unambiguous name"
+  }),
+  source: GenericObjectLocatorSchema.annotations({
+    description: "Source endpoint"
+  }),
+  target: GenericObjectLocatorSchema.annotations({
+    description: "Target endpoint"
+  }),
+  direction: Schema_exports.optional(RelationDirectionSchema.annotations({
+    description: relationDirectionDescription
+  }))
+}).annotations({
+  title: "DeleteRelationByTripleParams",
+  description: "Delete one concrete relation by exact association + source + target triple."
+});
+var DeleteRelationParamsSchema = Schema_exports.Union(
+  DeleteRelationByIdParamsSchema,
+  DeleteRelationByTripleParamsSchema
+).annotations({
+  title: "DeleteRelationParams",
+  description: "Parameters for idempotently deleting one concrete generic relation. Provide either relation, or the full association + source + target triple."
+});
+var DeleteRelationResultSchema = Schema_exports.Struct({
+  relationId: Schema_exports.optional(RelationId),
+  associationId: Schema_exports.optional(AssociationId),
+  deleted: Schema_exports.Boolean,
+  reason: Schema_exports.optional(Schema_exports.Literal("not_found", "deleted"))
+});
+var listAssociationsParamsJsonSchema = JSONSchema_exports.make(ListAssociationsParamsSchema);
+var createAssociationParamsJsonSchema = JSONSchema_exports.make(CreateAssociationParamsSchema);
+var deleteAssociationParamsJsonSchema = JSONSchema_exports.make(DeleteAssociationParamsSchema);
+var listRelationsParamsJsonSchema = {
+  ...JSONSchema_exports.make(ListRelationsParamsBaseSchema),
+  anyOf: [
+    { required: ["association"] },
+    { required: ["source"] },
+    { required: ["target"] }
+  ]
+};
+var createRelationParamsJsonSchema = JSONSchema_exports.make(CreateRelationParamsSchema);
+var deleteRelationParamsJsonSchema = {
+  ...JSONSchema_exports.make(DeleteRelationParamsSchema),
+  type: "object"
+};
+var strictParseOptions = { onExcessProperty: "error" };
+var parseListAssociationsParams = Schema_exports.decodeUnknown(ListAssociationsParamsSchema, strictParseOptions);
+var parseCreateAssociationParams = Schema_exports.decodeUnknown(CreateAssociationParamsSchema, strictParseOptions);
+var parseDeleteAssociationParams = Schema_exports.decodeUnknown(DeleteAssociationParamsSchema, strictParseOptions);
+var parseListRelationsParams = Schema_exports.decodeUnknown(ListRelationsParamsSchema, strictParseOptions);
+var parseCreateRelationParams = Schema_exports.decodeUnknown(CreateRelationParamsSchema, strictParseOptions);
+var parseDeleteRelationParams = Schema_exports.decodeUnknown(DeleteRelationParamsSchema, strictParseOptions);
+
 // src/huly/errors-generic-associations.ts
 var CandidateSchema = Schema_exports.Struct({
   id: AssociationId,
-  name: Schema_exports.optional(Schema_exports.String),
-  sourceClass: Schema_exports.optional(Schema_exports.String),
-  targetClass: Schema_exports.optional(Schema_exports.String)
+  name: Schema_exports.optional(AssociationName),
+  sourceClass: Schema_exports.optional(ObjectClassName),
+  targetClass: Schema_exports.optional(ObjectClassName)
 });
 var formatCandidates = (candidates) => candidates.map((candidate) => {
   const name = candidate.name === void 0 ? "" : `${candidate.name} `;
@@ -151419,6 +151712,64 @@ var RelationMutationUnsupportedError = class extends Schema_exports.TaggedError(
     return `Generic relation mutation${id} is not supported: ${this.reason}. Call list_associations with writableOnly=true to discover writable associations.`;
   }
 };
+var AssociationSystemClassUnsupportedError = class extends Schema_exports.TaggedError()(
+  "AssociationSystemClassUnsupportedError",
+  {
+    className: ObjectClassName,
+    operation: Schema_exports.Literal("create_association", "delete_association", "create_relation", "delete_relation")
+  }
+) {
+  get message() {
+    return `${this.operation} does not support core system class '${this.className}' in generic association writes.`;
+  }
+};
+var AssociationConflictError = class extends Schema_exports.TaggedError()(
+  "AssociationConflictError",
+  {
+    associationId: AssociationId,
+    reason: Schema_exports.String
+  }
+) {
+  get message() {
+    return `Association '${this.associationId}' already exists but conflicts with the requested definition: ${this.reason}.`;
+  }
+};
+var AssociationInUseError = class extends Schema_exports.TaggedError()(
+  "AssociationInUseError",
+  {
+    associationId: AssociationId,
+    relationCount: Schema_exports.Number,
+    sampleRelationIds: Schema_exports.Array(RelationId)
+  }
+) {
+  get message() {
+    const sample2 = this.sampleRelationIds.length === 0 ? "" : ` Sample relation IDs: ${this.sampleRelationIds.join(", ")}.`;
+    return `Association '${this.associationId}' cannot be deleted because ${this.relationCount} relation(s) still reference it. Delete those relations first.${sample2}`;
+  }
+};
+var RelationCardinalityViolationError = class extends Schema_exports.TaggedError()(
+  "RelationCardinalityViolationError",
+  {
+    associationId: AssociationId,
+    cardinality: CardinalitySchema,
+    reason: Schema_exports.String
+  }
+) {
+  get message() {
+    return `Relation violates ${this.cardinality} cardinality for association '${this.associationId}': ${this.reason}.`;
+  }
+};
+var RelationDirectionAmbiguousError = class extends Schema_exports.TaggedError()(
+  "RelationDirectionAmbiguousError",
+  {
+    associationId: AssociationId,
+    reason: Schema_exports.String
+  }
+) {
+  get message() {
+    return `Relation direction is ambiguous for association '${this.associationId}': ${this.reason}. Use source-to-target or target-to-source.`;
+  }
+};
 var RelationEndpointClassMismatchError = class extends Schema_exports.TaggedError()(
   "RelationEndpointClassMismatchError",
   {
@@ -152274,9 +152625,14 @@ var HulyDomainError = Schema_exports.Union(
   ProcessExecutionNotCancellableError,
   AssociationNotFoundError,
   AssociationIdentifierAmbiguousError,
+  AssociationSystemClassUnsupportedError,
+  AssociationConflictError,
+  AssociationInUseError,
   RelationNotFoundError,
   RelationIdentifierAmbiguousError,
   RelationMutationUnsupportedError,
+  RelationCardinalityViolationError,
+  RelationDirectionAmbiguousError,
   RelationEndpointClassMismatchError,
   GenericObjectIdentifierAmbiguousError,
   GenericObjectLocatorInvalidError,
@@ -172203,7 +172559,7 @@ var PostHog = class extends PostHogBackendClient {
 };
 
 // src/version.ts
-var VERSION = true ? "0.15.0" : "0.0.0-dev";
+var VERSION = true ? "0.16.0" : "0.0.0-dev";
 
 // src/telemetry/posthog.ts
 var POSTHOG_API_KEY = "phc_TGfFqCGdnF0p68wuFzd5WSw1IsBvOJW0YgoMJDyZPjm";
@@ -172387,9 +172743,14 @@ var INVALID_PARAMS_TAGS = /* @__PURE__ */ new Set([
   "ProcessCardNotFoundError",
   "AssociationNotFoundError",
   "AssociationIdentifierAmbiguousError",
+  "AssociationSystemClassUnsupportedError",
+  "AssociationConflictError",
+  "AssociationInUseError",
   "RelationNotFoundError",
   "RelationIdentifierAmbiguousError",
   "RelationMutationUnsupportedError",
+  "RelationCardinalityViolationError",
+  "RelationDirectionAmbiguousError",
   "RelationEndpointClassMismatchError",
   "GenericObjectIdentifierAmbiguousError",
   "GenericObjectLocatorInvalidError",
@@ -172458,6 +172819,40 @@ var toMcpResponse = (response) => {
   return wire;
 };
 
+// src/mcp/input-schema-compat.ts
+var ROOT_COMPOSITION_KEYS = /* @__PURE__ */ new Set(["anyOf", "oneOf", "allOf"]);
+var isRecord2 = (value3) => typeof value3 === "object" && value3 !== null && !Array.isArray(value3);
+var isObjectSchema = (schema) => "type" in schema && schema.type === "object";
+var mergeObjectFields = (sources) => {
+  const merged = sources.reduce(
+    (acc, source) => isRecord2(source) ? { ...source, ...acc } : acc,
+    {}
+  );
+  return Object.keys(merged).length > 0 ? merged : void 0;
+};
+var rootCompositionBranches = (schema) => [...ROOT_COMPOSITION_KEYS].flatMap((key) => {
+  const branches = schema[key];
+  return Array.isArray(branches) ? branches.filter(isRecord2) : [];
+});
+var schemaAndCompositionDescendants = (schema) => [
+  schema,
+  ...rootCompositionBranches(schema).flatMap(schemaAndCompositionDescendants)
+];
+var mergedSchemaField = (schema, field) => mergeObjectFields(schemaAndCompositionDescendants(schema).map((branch) => branch[field]));
+var toClientCompatibleInputSchema = (schema) => {
+  const rootFields = Object.fromEntries(
+    Object.entries(schema).filter(([key]) => key !== "type" && !ROOT_COMPOSITION_KEYS.has(key))
+  );
+  const properties = mergedSchemaField(schema, "properties");
+  const defs = mergedSchemaField(schema, "$defs");
+  return {
+    ...rootFields,
+    type: "object",
+    ...properties === void 0 ? {} : { properties },
+    ...defs === void 0 ? {} : { $defs: defs }
+  };
+};
+
 // src/mcp/tool-output-schema.ts
 var defaultToolOutputSchema = {
   type: "object",
@@ -175928,242 +176323,6 @@ var calendarTools = [
   }
 ];
 
-// src/domain/schemas/generic-associations.ts
-var AssociationIdentifier = NonEmptyString2.pipe(Schema_exports.brand("AssociationIdentifier"));
-var RelationIdentifier = NonEmptyString2.pipe(Schema_exports.brand("RelationIdentifier"));
-var ListRelationsWarning = NonEmptyString2.pipe(Schema_exports.brand("ListRelationsWarning"));
-var CardinalityValues = [
-  "one-to-one",
-  "one-to-many",
-  "many-to-many"
-];
-var CardinalitySchema = Schema_exports.Literal(...CardinalityValues).annotations({
-  description: `Association cardinality: ${enumValuesDescription(CardinalityValues)}`
-});
-var RelationDirectionValues = ["source-to-target", "target-to-source", "either"];
-var RelationDirectionSchema = Schema_exports.Literal(...RelationDirectionValues);
-var DefaultRelationDirection = "source-to-target";
-var relationDirectionDescription = `Relation traversal direction: ${enumValuesDescription(RelationDirectionValues)}. Defaults to ${DefaultRelationDirection}.`;
-var RelationIfExistsSchema = Schema_exports.Literal("return_existing", "fail");
-var RawObjectLocatorSchema = Schema_exports.Struct({
-  kind: Schema_exports.Literal("raw"),
-  id: DocId.annotations({
-    description: "Raw Huly document _id"
-  }),
-  class: Schema_exports.optional(ObjectClassName.annotations({
-    description: "Raw Huly document class, such as tracker:class:Issue. Required unless the association side determines the expected class."
-  }))
-});
-var IssueObjectLocatorSchema = Schema_exports.Struct({
-  kind: Schema_exports.Literal("issue"),
-  issue: IssueIdentifier.annotations({
-    description: "Issue identifier, such as HULY-123, or a numeric issue number when project is also provided."
-  }),
-  project: Schema_exports.optional(ProjectIdentifier.annotations({
-    description: "Project identifier. Optional when issue already includes a project prefix like HULY-123."
-  }))
-});
-var DocumentObjectLocatorSchema = Schema_exports.Struct({
-  kind: Schema_exports.Literal("document"),
-  document: DocumentIdentifier.annotations({
-    description: "Document title or ID"
-  }),
-  teamspace: Schema_exports.optional(TeamspaceIdentifier.annotations({
-    description: "Teamspace name or ID. If omitted, document title matches must be unique across the workspace."
-  }))
-});
-var GenericObjectLocatorSchema = Schema_exports.Union(
-  RawObjectLocatorSchema,
-  IssueObjectLocatorSchema,
-  DocumentObjectLocatorSchema
-).annotations({
-  title: "GenericObjectLocator",
-  description: "Explicit locator for a Huly document endpoint. Use raw for known _id values, issue for tracker issues, or document for Huly documents. Card locators are intentionally not included until a robust card resolver is available."
-});
-var ResolvedObjectSummarySchema = Schema_exports.Struct({
-  id: DocId,
-  class: ObjectClassName,
-  display: NonEmptyString2,
-  locatorKind: Schema_exports.Literal("raw", "issue", "document"),
-  warning: Schema_exports.optional(Schema_exports.String)
-});
-var AssociationSummarySchema = Schema_exports.Struct({
-  associationId: AssociationId,
-  name: Schema_exports.optional(NonEmptyString2),
-  label: Schema_exports.optional(NonEmptyString2),
-  description: Schema_exports.optional(Schema_exports.String),
-  sourceClass: ObjectClassName,
-  sourceClassLabel: Schema_exports.optional(NonEmptyString2.annotations({
-    description: "Best-effort human display label for sourceClass when the class is known to this server"
-  })),
-  targetClass: ObjectClassName,
-  targetClassLabel: Schema_exports.optional(NonEmptyString2.annotations({
-    description: "Best-effort human display label for targetClass when the class is known to this server"
-  })),
-  sourceRole: Schema_exports.optional(NonEmptyString2),
-  targetRole: Schema_exports.optional(NonEmptyString2),
-  relationClass: Schema_exports.optional(ObjectClassName),
-  cardinality: CardinalitySchema,
-  symmetric: Schema_exports.Boolean,
-  system: Schema_exports.Boolean,
-  canListRelations: Schema_exports.Boolean,
-  canCreateRelation: Schema_exports.Boolean,
-  canDeleteRelation: Schema_exports.Boolean,
-  unsupportedReason: Schema_exports.optional(Schema_exports.String)
-});
-var RelationSummarySchema = Schema_exports.Struct({
-  relationId: RelationId,
-  associationId: AssociationId,
-  associationName: Schema_exports.optional(NonEmptyString2),
-  source: ResolvedObjectSummarySchema,
-  target: ResolvedObjectSummarySchema,
-  createdOn: Schema_exports.optional(Timestamp),
-  modifiedOn: Schema_exports.optional(Timestamp)
-});
-var ListAssociationsParamsSchema = Schema_exports.Struct({
-  association: Schema_exports.optional(AssociationIdentifier.annotations({
-    description: "Association _id, source/target role name, or stable association name"
-  })),
-  sourceClass: Schema_exports.optional(ObjectClassName.annotations({
-    description: "Only return associations whose source class matches this Huly class ID"
-  })),
-  targetClass: Schema_exports.optional(ObjectClassName.annotations({
-    description: "Only return associations whose target class matches this Huly class ID"
-  })),
-  writableOnly: Schema_exports.optional(Schema_exports.Boolean.annotations({
-    description: "Only return associations whose relation create/delete path has been validated and allowlisted"
-  })),
-  includeSystem: Schema_exports.optional(Schema_exports.Boolean.annotations({
-    description: "Include internal/system associations. Defaults to false."
-  })),
-  limit: Schema_exports.optional(LimitParam.annotations({
-    description: "Maximum number of associations to return (default: 50)"
-  }))
-}).annotations({
-  title: "ListAssociationsParams",
-  description: "Parameters for listing generic Huly association definitions"
-});
-var ListAssociationsResultSchema = Schema_exports.Struct({
-  associations: Schema_exports.Array(AssociationSummarySchema),
-  total: Schema_exports.Number
-});
-var ListRelationsParamsBaseSchema = Schema_exports.Struct({
-  association: Schema_exports.optional(AssociationIdentifier.annotations({
-    description: "Association _id or name. If omitted, relations are listed only across supported visible associations."
-  })),
-  source: Schema_exports.optional(GenericObjectLocatorSchema.annotations({
-    description: "Optional source endpoint filter"
-  })),
-  target: Schema_exports.optional(GenericObjectLocatorSchema.annotations({
-    description: "Optional target endpoint filter"
-  })),
-  direction: Schema_exports.optional(RelationDirectionSchema.annotations({
-    description: relationDirectionDescription
-  })),
-  limit: Schema_exports.optional(LimitParam.annotations({
-    description: "Maximum number of relations to return (default: 50)"
-  }))
-}).annotations({
-  title: "ListRelationsParams",
-  description: "Parameters for listing concrete Huly relation instances"
-});
-var ListRelationsParamsSchema = ListRelationsParamsBaseSchema.pipe(
-  Schema_exports.filter(
-    (params) => params.association === void 0 && params.source === void 0 && params.target === void 0 ? "Provide at least one of association, source, or target to avoid broad workspace scans." : void 0
-  )
-).annotations({
-  title: "ListRelationsParams",
-  description: "Parameters for listing concrete Huly relation instances"
-});
-var ListRelationsResultSchema = Schema_exports.Struct({
-  relations: Schema_exports.Array(RelationSummarySchema),
-  total: Schema_exports.Number,
-  warnings: Schema_exports.optional(
-    Schema_exports.NonEmptyArray(ListRelationsWarning).annotations({
-      description: "Non-fatal warnings about result completeness or resolution. Treat these as guidance for narrowing a follow-up call."
-    })
-  )
-});
-var CreateRelationParamsSchema = Schema_exports.Struct({
-  association: AssociationIdentifier.annotations({
-    description: "Association _id or unambiguous name returned by list_associations"
-  }),
-  source: GenericObjectLocatorSchema.annotations({
-    description: "Source endpoint document"
-  }),
-  target: GenericObjectLocatorSchema.annotations({
-    description: "Target endpoint document"
-  }),
-  ifExists: Schema_exports.optional(RelationIfExistsSchema.annotations({
-    description: "return_existing (default) returns an existing relation; fail reports an existing relation as an error"
-  }))
-}).annotations({
-  title: "CreateRelationParams",
-  description: "Parameters for idempotently creating a concrete generic relation"
-});
-var CreateRelationResultSchema = Schema_exports.Struct({
-  relationId: RelationId,
-  associationId: AssociationId,
-  source: ResolvedObjectSummarySchema,
-  target: ResolvedObjectSummarySchema,
-  created: Schema_exports.Boolean,
-  existing: Schema_exports.Boolean
-});
-var DeleteRelationByIdParamsSchema = Schema_exports.Struct({
-  relation: RelationIdentifier.annotations({
-    description: "Concrete relation _id to delete"
-  })
-}).annotations({
-  title: "DeleteRelationByIdParams",
-  description: "Delete one concrete relation by its relation ID."
-});
-var DeleteRelationByTripleParamsSchema = Schema_exports.Struct({
-  association: AssociationIdentifier.annotations({
-    description: "Association _id or unambiguous name"
-  }),
-  source: GenericObjectLocatorSchema.annotations({
-    description: "Source endpoint"
-  }),
-  target: GenericObjectLocatorSchema.annotations({
-    description: "Target endpoint"
-  })
-}).annotations({
-  title: "DeleteRelationByTripleParams",
-  description: "Delete one concrete relation by exact association + source + target triple."
-});
-var DeleteRelationParamsSchema = Schema_exports.Union(
-  DeleteRelationByIdParamsSchema,
-  DeleteRelationByTripleParamsSchema
-).annotations({
-  title: "DeleteRelationParams",
-  description: "Parameters for idempotently deleting one concrete generic relation. Provide either relation, or the full association + source + target triple."
-});
-var DeleteRelationResultSchema = Schema_exports.Struct({
-  relationId: Schema_exports.optional(RelationId),
-  associationId: Schema_exports.optional(AssociationId),
-  deleted: Schema_exports.Boolean,
-  reason: Schema_exports.optional(Schema_exports.Literal("not_found", "deleted"))
-});
-var listAssociationsParamsJsonSchema = JSONSchema_exports.make(ListAssociationsParamsSchema);
-var listRelationsParamsJsonSchema = {
-  ...JSONSchema_exports.make(ListRelationsParamsBaseSchema),
-  anyOf: [
-    { required: ["association"] },
-    { required: ["source"] },
-    { required: ["target"] }
-  ]
-};
-var createRelationParamsJsonSchema = JSONSchema_exports.make(CreateRelationParamsSchema);
-var deleteRelationParamsJsonSchema = {
-  ...JSONSchema_exports.make(DeleteRelationParamsSchema),
-  type: "object"
-};
-var strictParseOptions = { onExcessProperty: "error" };
-var parseListAssociationsParams = Schema_exports.decodeUnknown(ListAssociationsParamsSchema, strictParseOptions);
-var parseListRelationsParams = Schema_exports.decodeUnknown(ListRelationsParamsSchema, strictParseOptions);
-var parseCreateRelationParams = Schema_exports.decodeUnknown(CreateRelationParamsSchema, strictParseOptions);
-var parseDeleteRelationParams = Schema_exports.decodeUnknown(DeleteRelationParamsSchema, strictParseOptions);
-
 // src/domain/schemas/projects.ts
 var ProjectSummarySchema = Schema_exports.Struct({
   identifier: ProjectIdentifier,
@@ -182081,7 +182240,6 @@ var documentTools = [
 
 // src/huly/operations/generic-associations.ts
 var import_core35 = __toESM(require_lib4(), 1);
-var WRITE_UNSUPPORTED_REASON = "no generic association relation write path has been live-validated for this workspace";
 var ASSOCIATION_DISCOVERY_LIMIT = 200;
 var ASSOCIATION_DISCOVERY_LIMIT_WARNING = ListRelationsWarning.make(
   `Association discovery reached the local ${ASSOCIATION_DISCOVERY_LIMIT}-association cap for at least one endpoint orientation. Huly did not indicate whether more matching associations exist, so list_relations may omit older matching associations; pass a specific association from list_associations to avoid this discovery cap.`
@@ -182097,8 +182255,7 @@ var VISIBLE_ASSOCIATION_FILTERS = {
   sourceClass: void 0,
   targetClass: void 0
 };
-var associationName = (association) => association.nameA === association.nameB ? association.nameA : `${association.nameA} -> ${association.nameB}`;
-var optionalNonEmpty = (value3) => value3 === void 0 ? void 0 : NonEmptyString2.make(value3);
+var associationName = (association) => association.nameA === association.nameB ? AssociationName.make(association.nameA) : AssociationName.make(`${association.nameA} -> ${association.nameB}`);
 var classLabelEntry = (classRef2, label) => [
   ObjectClassName.make(classRef2),
   NonEmptyString2.make(label)
@@ -182116,7 +182273,19 @@ var KNOWN_CLASS_LABELS = new Map([
   classLabelEntry(tracker.class.Milestone, "Milestone")
 ]);
 var classLabel = (classRef2) => KNOWN_CLASS_LABELS.get(classRef2);
-var isSystemAssociation = (association) => String(association.classA).startsWith("core:class:") || String(association.classB).startsWith("core:class:");
+var isSystemClassName = (className) => className.startsWith("core:class:");
+var isSystemAssociation = (association) => isSystemClassName(String(association.classA)) || isSystemClassName(String(association.classB));
+var associationAutomationOnly = (association) => association.automationOnly === true;
+var relationWriteUnsupportedReason = (association) => {
+  if (isSystemAssociation(association)) {
+    return "association uses a core:class:* system class";
+  }
+  if (associationAutomationOnly(association)) {
+    return "association is automation-only";
+  }
+  return void 0;
+};
+var isRelationWritableAssociation = (association) => relationWriteUnsupportedReason(association) === void 0;
 var isSymmetric = (association) => association.classA === association.classB && association.nameA === association.nameB;
 var ASSOCIATION_CARDINALITY = {
   "1:1": "one-to-one",
@@ -182126,33 +182295,39 @@ var ASSOCIATION_CARDINALITY = {
 var exactCardinalityMapping = (value3) => value3;
 exactCardinalityMapping(true);
 var cardinality = (type) => ASSOCIATION_CARDINALITY[type];
+var SDK_CARDINALITY = {
+  "one-to-one": "1:1",
+  "one-to-many": "1:N",
+  "many-to-many": "N:N"
+};
 var toAssociationSummary = (association) => {
   const sourceClass = ObjectClassName.make(association.classA);
   const targetClass = ObjectClassName.make(association.classB);
+  const unsupportedReason = relationWriteUnsupportedReason(association);
   return {
     associationId: AssociationId.make(association._id),
-    name: optionalNonEmpty(associationName(association)),
+    name: associationName(association),
     sourceClass,
     sourceClassLabel: classLabel(sourceClass),
     targetClass,
     targetClassLabel: classLabel(targetClass),
-    sourceRole: NonEmptyString2.make(association.nameA),
-    targetRole: NonEmptyString2.make(association.nameB),
+    sourceRole: AssociationRoleName.make(association.nameA),
+    targetRole: AssociationRoleName.make(association.nameB),
     relationClass: ObjectClassName.make(core.class.Relation),
     cardinality: cardinality(association.type),
     symmetric: isSymmetric(association),
     system: isSystemAssociation(association),
     canListRelations: true,
-    canCreateRelation: false,
-    canDeleteRelation: false,
-    unsupportedReason: WRITE_UNSUPPORTED_REASON
+    canCreateRelation: unsupportedReason === void 0,
+    canDeleteRelation: unsupportedReason === void 0,
+    ...unsupportedReason === void 0 ? {} : { unsupportedReason }
   };
 };
 var toCandidate = (association) => ({
   id: AssociationId.make(association._id),
   name: associationName(association),
-  sourceClass: association.classA,
-  targetClass: association.classB
+  sourceClass: ObjectClassName.make(association.classA),
+  targetClass: ObjectClassName.make(association.classB)
 });
 var matchesAssociationIdentifier = (association, identifier2) => {
   const normalized = identifier2.trim().toLowerCase();
@@ -182169,7 +182344,7 @@ var associationListFiltersFromParams = (params) => ({
 });
 var associationMatchesFilters = (association, filters) => (filters.includeSystem || !isSystemAssociation(association)) && (filters.sourceClass === void 0 || association.classA === String(filters.sourceClass)) && (filters.targetClass === void 0 || association.classB === String(filters.targetClass));
 var filterVisible = (associations, filters) => associations.filter(
-  (association) => associationMatchesFilters(association, filters) && !filters.writableOnly
+  (association) => associationMatchesFilters(association, filters) && (!filters.writableOnly || isRelationWritableAssociation(association))
 );
 var listAssociationDocs = (client, params) => {
   const query = {};
@@ -182266,6 +182441,155 @@ var resolveAssociation = (client, identifier2, filters) => Effect_exports.gen(fu
   }
   return candidates[0];
 });
+var rejectSystemClass = (className, operation) => isSystemClassName(String(className)) ? Effect_exports.fail(new AssociationSystemClassUnsupportedError({ className, operation })) : Effect_exports.void;
+var systemClassInAssociation = (association) => {
+  if (isSystemClassName(String(association.classA))) {
+    return ObjectClassName.make(association.classA);
+  }
+  if (isSystemClassName(String(association.classB))) {
+    return ObjectClassName.make(association.classB);
+  }
+  return void 0;
+};
+var ensureRelationMutationSupported = (association, operation) => {
+  const systemClass = systemClassInAssociation(association);
+  if (systemClass !== void 0) {
+    return Effect_exports.fail(new AssociationSystemClassUnsupportedError({ className: systemClass, operation }));
+  }
+  if (associationAutomationOnly(association)) {
+    return Effect_exports.fail(
+      new RelationMutationUnsupportedError({
+        associationId: AssociationId.make(association._id),
+        reason: "association is automation-only"
+      })
+    );
+  }
+  return Effect_exports.void;
+};
+var exactAssociationQuery = (params) => ({
+  classA: toClassRef(params.sourceClass),
+  classB: toClassRef(params.targetClass),
+  nameA: params.sourceRole,
+  nameB: params.targetRole
+});
+var createdAssociationSummaryInput = (id, params) => ({
+  _id: id,
+  classA: toClassRef(params.sourceClass),
+  classB: toClassRef(params.targetClass),
+  nameA: params.sourceRole,
+  nameB: params.targetRole,
+  type: SDK_CARDINALITY[params.cardinality],
+  automationOnly: params.automationOnly ?? false
+});
+var createAssociation = (params) => Effect_exports.gen(function* () {
+  const client = yield* HulyClient;
+  yield* rejectSystemClass(params.sourceClass, "create_association");
+  yield* rejectSystemClass(params.targetClass, "create_association");
+  const existing = yield* client.findOne(
+    core.class.Association,
+    hulyQuery(exactAssociationQuery(params))
+  );
+  if (existing !== void 0) {
+    if (params.ifExists === "fail") {
+      return yield* new AssociationConflictError({
+        associationId: AssociationId.make(existing._id),
+        reason: "ifExists=fail was requested"
+      });
+    }
+    if (cardinality(existing.type) !== params.cardinality) {
+      return yield* new AssociationConflictError({
+        associationId: AssociationId.make(existing._id),
+        reason: `existing cardinality is ${cardinality(existing.type)}, requested ${params.cardinality}`
+      });
+    }
+    if (associationAutomationOnly(existing) !== (params.automationOnly ?? false)) {
+      return yield* new AssociationConflictError({
+        associationId: AssociationId.make(existing._id),
+        reason: `existing automationOnly is ${associationAutomationOnly(existing)}, requested ${params.automationOnly ?? false}`
+      });
+    }
+    return {
+      association: toAssociationSummary(existing),
+      created: false,
+      existing: true
+    };
+  }
+  const attributes = {
+    classA: toClassRef(params.sourceClass),
+    classB: toClassRef(params.targetClass),
+    nameA: params.sourceRole,
+    nameB: params.targetRole,
+    type: SDK_CARDINALITY[params.cardinality],
+    automationOnly: params.automationOnly ?? false
+  };
+  const associationId = yield* client.createDoc(
+    core.class.Association,
+    toRef(core.space.Model),
+    attributes
+  );
+  return {
+    association: toAssociationSummary(createdAssociationSummaryInput(associationId, params)),
+    created: true,
+    existing: false
+  };
+});
+var ensureAssociationDeletionSupported = (association) => {
+  const systemClass = systemClassInAssociation(association);
+  return systemClass === void 0 ? Effect_exports.void : Effect_exports.fail(
+    new AssociationSystemClassUnsupportedError({
+      className: systemClass,
+      operation: "delete_association"
+    })
+  );
+};
+var countAssociationRelations = (client, association) => Effect_exports.map(
+  client.findAll(
+    core.class.Relation,
+    hulyQuery({
+      association: toRef(association._id)
+    }),
+    { limit: 5 }
+  ),
+  (relations) => ({
+    total: Math.max(relations.total, relations.length),
+    sampleRelationIds: relations.map((relation) => RelationId.make(relation._id))
+  })
+);
+var deleteAssociation = (params) => Effect_exports.gen(function* () {
+  const client = yield* HulyClient;
+  const association = yield* resolveAssociation(
+    client,
+    params.association,
+    MUTATION_ASSOCIATION_FILTERS
+  ).pipe(
+    Effect_exports.catchTag("AssociationNotFoundError", () => Effect_exports.succeed(void 0))
+  );
+  if (association === void 0) {
+    return {
+      association: params.association,
+      deleted: false,
+      relationCount: 0,
+      reason: "not_found"
+    };
+  }
+  yield* ensureAssociationDeletionSupported(association);
+  const relationUsage = yield* countAssociationRelations(client, association);
+  if (relationUsage.total > 0) {
+    return yield* new AssociationInUseError({
+      associationId: AssociationId.make(association._id),
+      relationCount: relationUsage.total,
+      sampleRelationIds: relationUsage.sampleRelationIds
+    });
+  }
+  yield* client.removeDoc(core.class.Association, association.space, association._id);
+  return {
+    association: params.association,
+    associationId: AssociationId.make(association._id),
+    deleted: true,
+    relationCount: 0,
+    reason: "deleted"
+  };
+});
 var listAssociations = (params) => Effect_exports.gen(function* () {
   const client = yield* HulyClient;
   if (params.association !== void 0) {
@@ -182480,7 +182804,7 @@ var resolveRelationEndpointFromCache = (docsByClass, id, className) => {
 var relationToSummary = (association, relation, docsByClass) => ({
   relationId: RelationId.make(relation._id),
   associationId: AssociationId.make(association._id),
-  associationName: optionalNonEmpty(associationName(association)),
+  associationName: associationName(association),
   source: resolveRelationEndpointFromCache(docsByClass, relation.docA, association.classA),
   target: resolveRelationEndpointFromCache(docsByClass, relation.docB, association.classB),
   createdOn: relation.createdOn,
@@ -182718,21 +183042,182 @@ var listRelations = (params) => Effect_exports.gen(function* () {
     total: summaries.length
   };
 });
+var resolveRelationWriteEndpoints = (client, association, params) => Effect_exports.gen(function* () {
+  const direction = params.direction ?? DefaultRelationDirection;
+  if (direction === "source-to-target") {
+    const source2 = yield* resolveGenericObject(client, params.source, association.classA, "source");
+    const target2 = yield* resolveGenericObject(client, params.target, association.classB, "target");
+    return { docA: source2, docB: target2, source: source2, target: target2 };
+  }
+  if (direction === "target-to-source") {
+    const source2 = yield* resolveGenericObject(client, params.source, association.classB, "source");
+    const target2 = yield* resolveGenericObject(client, params.target, association.classA, "target");
+    return { docA: target2, docB: source2, source: source2, target: target2 };
+  }
+  const source = yield* resolveGenericObject(client, params.source, void 0, "source");
+  const target = yield* resolveGenericObject(client, params.target, void 0, "target");
+  const matchesForward = String(source.class) === association.classA && String(target.class) === association.classB;
+  const matchesReverse = String(source.class) === association.classB && String(target.class) === association.classA;
+  if (matchesForward && matchesReverse) {
+    return yield* new RelationDirectionAmbiguousError({
+      associationId: AssociationId.make(association._id),
+      reason: "both endpoints match both sides of the association"
+    });
+  }
+  if (matchesForward) {
+    return { docA: source, docB: target, source, target };
+  }
+  if (matchesReverse) {
+    return { docA: target, docB: source, source, target };
+  }
+  yield* validateEitherEndpointClasses(association, source, target);
+  return yield* new RelationEndpointClassMismatchError({
+    field: "source",
+    expectedClass: `${association.classA} or ${association.classB}`,
+    actualClass: source.class
+  });
+});
+var exactRelationQuery = (association, endpoints) => ({
+  association: toRef(association._id),
+  docA: toRef(endpoints.docA.id),
+  docB: toRef(endpoints.docB.id)
+});
+var findExactRelations = (client, association, endpoints, limit) => Effect_exports.map(
+  client.findAll(
+    core.class.Relation,
+    hulyQuery(exactRelationQuery(association, endpoints)),
+    { limit }
+  ),
+  (relations) => [...relations]
+);
+var findCardinalityConflict = (client, association, endpoints) => Effect_exports.gen(function* () {
+  if (association.type === "N:N") {
+    return void 0;
+  }
+  const docBConflict = yield* client.findOne(
+    core.class.Relation,
+    hulyQuery({
+      association: toRef(association._id),
+      docB: toRef(endpoints.docB.id)
+    })
+  );
+  if (docBConflict !== void 0) {
+    return docBConflict;
+  }
+  if (association.type === "1:1") {
+    return yield* client.findOne(
+      core.class.Relation,
+      hulyQuery({
+        association: toRef(association._id),
+        docA: toRef(endpoints.docA.id)
+      })
+    );
+  }
+  return void 0;
+});
+var enforceCardinality = (client, association, endpoints) => Effect_exports.gen(function* () {
+  const conflict = yield* findCardinalityConflict(client, association, endpoints);
+  if (conflict === void 0) {
+    return;
+  }
+  const reason = association.type === "1:1" ? "one-to-one associations allow each endpoint to appear in only one relation" : "one-to-many associations allow each target-side endpoint to appear in only one relation";
+  return yield* new RelationCardinalityViolationError({
+    associationId: AssociationId.make(association._id),
+    cardinality: cardinality(association.type),
+    reason
+  });
+});
 var createRelation = (params) => Effect_exports.gen(function* () {
   const client = yield* HulyClient;
   const association = yield* resolveAssociation(client, params.association, MUTATION_ASSOCIATION_FILTERS);
-  return yield* new RelationMutationUnsupportedError({
+  yield* ensureRelationMutationSupported(association, "create_relation");
+  const endpoints = yield* resolveRelationWriteEndpoints(client, association, params);
+  const exact = yield* findExactRelations(client, association, endpoints, 1);
+  const existing = exact.at(0);
+  if (existing !== void 0) {
+    if (params.ifExists === "fail") {
+      return yield* new RelationCardinalityViolationError({
+        associationId: AssociationId.make(association._id),
+        cardinality: cardinality(association.type),
+        reason: `relation '${existing._id}' already exists`
+      });
+    }
+    return {
+      relationId: RelationId.make(existing._id),
+      associationId: AssociationId.make(association._id),
+      source: endpoints.source,
+      target: endpoints.target,
+      created: false,
+      existing: true
+    };
+  }
+  yield* enforceCardinality(client, association, endpoints);
+  const relationId = yield* client.createDoc(
+    core.class.Relation,
+    toRef(core.space.Workspace),
+    {
+      association: toRef(association._id),
+      docA: toRef(endpoints.docA.id),
+      docB: toRef(endpoints.docB.id)
+    }
+  );
+  return {
+    relationId: RelationId.make(relationId),
     associationId: AssociationId.make(association._id),
-    reason: WRITE_UNSUPPORTED_REASON
-  });
+    source: endpoints.source,
+    target: endpoints.target,
+    created: true,
+    existing: false
+  };
 });
 var deleteRelation = (params) => Effect_exports.gen(function* () {
   const client = yield* HulyClient;
-  const association = "association" in params ? yield* resolveAssociation(client, params.association, MUTATION_ASSOCIATION_FILTERS) : void 0;
-  return yield* new RelationMutationUnsupportedError({
-    associationId: association === void 0 ? void 0 : AssociationId.make(association._id),
-    reason: WRITE_UNSUPPORTED_REASON
-  });
+  if ("relation" in params) {
+    const existing = yield* client.findOne(
+      core.class.Relation,
+      hulyQuery({ _id: toRef(params.relation) })
+    );
+    if (existing === void 0) {
+      return {
+        relationId: RelationId.make(params.relation),
+        deleted: false,
+        reason: "not_found"
+      };
+    }
+    const association2 = yield* resolveAssociation(client, existing.association, MUTATION_ASSOCIATION_FILTERS);
+    yield* ensureRelationMutationSupported(association2, "delete_relation");
+    yield* client.removeDoc(core.class.Relation, existing.space, existing._id);
+    return {
+      relationId: RelationId.make(existing._id),
+      associationId: AssociationId.make(association2._id),
+      deleted: true,
+      reason: "deleted"
+    };
+  }
+  const association = yield* resolveAssociation(client, params.association, MUTATION_ASSOCIATION_FILTERS);
+  yield* ensureRelationMutationSupported(association, "delete_relation");
+  const endpoints = yield* resolveRelationWriteEndpoints(client, association, params);
+  const matches = yield* findExactRelations(client, association, endpoints, 2);
+  if (matches.length === 0) {
+    return {
+      associationId: AssociationId.make(association._id),
+      deleted: false,
+      reason: "not_found"
+    };
+  }
+  if (matches.length > 1) {
+    return yield* new RelationIdentifierAmbiguousError({
+      identifier: `${params.association}/${endpoints.docA.id}/${endpoints.docB.id}`,
+      relationIds: matches.map((relation) => RelationId.make(relation._id))
+    });
+  }
+  yield* client.removeDoc(core.class.Relation, matches[0].space, matches[0]._id);
+  return {
+    relationId: RelationId.make(matches[0]._id),
+    associationId: AssociationId.make(association._id),
+    deleted: true,
+    reason: "deleted"
+  };
 });
 
 // src/mcp/tools/generic-associations.ts
@@ -182750,6 +183235,42 @@ var genericAssociationTools = [
       ListAssociationsResultSchema
     )
   },
+  {
+    name: "create_association",
+    description: "Idempotently create one Huly association definition between two non-system classes. Use sourceClass/targetClass with sourceRole/targetRole and cardinality; returns an existing identical association by default.",
+    category: CATEGORY11,
+    inputSchema: createAssociationParamsJsonSchema,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    handler: createEncodedToolHandler(
+      "create_association",
+      parseCreateAssociationParams,
+      createAssociation,
+      CreateAssociationResultSchema
+    )
+  },
+  {
+    name: "delete_association",
+    description: "Idempotently delete one Huly association definition only when no concrete relations reference it. If relations exist, delete_relation must clean them up first; deleting an already-missing association is a successful no-op.",
+    category: CATEGORY11,
+    inputSchema: deleteAssociationParamsJsonSchema,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    handler: createEncodedToolHandler(
+      "delete_association",
+      parseDeleteAssociationParams,
+      deleteAssociation,
+      DeleteAssociationResultSchema
+    )
+  },
   {
     name: "list_relations",
     description: "List concrete Huly relation instances under an association, optionally filtered by source and target documents. Requires at least one filter to avoid broad workspace scans.",
@@ -182764,7 +183285,7 @@ var genericAssociationTools = [
   },
   {
     name: "create_relation",
-    description: "Idempotently create one concrete relation between two resolved documents. Only succeeds for associations where list_associations reports canCreateRelation=true; otherwise it fails clearly. This build currently reports no generic associations as writable until a write allowlist is live-validated.",
+    description: "Idempotently create one concrete relation between two resolved documents for a writable association. Enforces association endpoint classes, direction, duplicate handling, automation-only restrictions, and cardinality.",
     category: CATEGORY11,
     inputSchema: createRelationParamsJsonSchema,
     annotations: {
@@ -182782,9 +183303,15 @@ var genericAssociationTools = [
   },
   {
     name: "delete_relation",
-    description: "Idempotently delete one concrete relation by relation ID or by exact association/source/target triple. Only succeeds for associations where list_associations reports canDeleteRelation=true; otherwise it fails clearly. This build currently reports no generic associations as writable until a write allowlist is live-validated.",
+    description: "Idempotently delete one concrete relation by relation ID or by exact association/source/target triple. Triple deletes use the same direction semantics as create_relation and fail if the selector is ambiguous.",
     category: CATEGORY11,
     inputSchema: deleteRelationParamsJsonSchema,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
     handler: createEncodedToolHandler(
       "delete_relation",
       parseDeleteRelationParams,
@@ -188643,7 +189170,6 @@ var handleVersionTool = async () => {
   const latest = await fetchLatestNpmVersion();
   return createSuccessResponse({ current: VERSION, latest });
 };
-var isObjectSchema = (schema) => "type" in schema && schema.type === "object";
 var McpServerError = class extends Schema_exports.TaggedError()(
   "McpServerError",
   {
@@ -188709,7 +189235,7 @@ var createMcpServer = (resolveClients, telemetry, registry2, createServer = () =
           return [{
             name: tool.name,
             description: tool.description,
-            inputSchema: tool.inputSchema,
+            inputSchema: toClientCompatibleInputSchema(tool.inputSchema),
             outputSchema: defaultToolOutputSchema,
             annotations: resolveAnnotations(tool)
           }];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firfi/huly-mcp",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "MCP server for Huly integration",
   "mcpName": "io.github.dearlordylord/huly-mcp",
   "type": "module",
@@ -107,10 +107,10 @@
     "check-format": "find src test -name '*.ts' -print0 | xargs -0 eslint --rule '@effect/dprint: error'",
     "check-all": "pnpm build && pnpm typecheck && pnpm verify-registry-metadata && pnpm lint && pnpm test",
     "circular": "madge --extensions ts --circular src",
-    "local-release": "changeset version && pnpm sync-registry-metadata && pnpm build && pnpm verify-version && changeset publish",
+    "local-release": "pnpm dlx @changesets/cli@2.30.0 version && pnpm sync-registry-metadata && git add package.json CHANGELOG.md server.json .changeset && (git diff --cached --quiet || HUSKY=0 git commit -m \"RELEASING: Releasing 1 package(s)\") && PKG_VERSION=$(node -p \"require('./package.json').version\") && pnpm dlx esbuild@0.27.2 src/index.ts --bundle --platform=node --format=cjs --outfile=dist/index.cjs --external:ws \"--define:PKG_VERSION=\\\"$PKG_VERSION\\\"\" && pnpm verify-version && npm_config_ignore_scripts=true pnpm dlx @changesets/cli@2.30.0 publish",
     "verify-version": "node -e \"const v=require('./package.json').version; const d=require('fs').readFileSync('dist/index.cjs','utf8'); if(!d.includes('\\\"'+v+'\\\"'))throw new Error('dist version mismatch: expected '+v)\"",
-    "verify-registry-metadata": "tsx scripts/sync-registry-metadata.ts --check",
-    "sync-registry-metadata": "tsx scripts/sync-registry-metadata.ts",
-    "update-readme": "tsx scripts/update-readme-tools.ts"
+    "verify-registry-metadata": "node scripts/sync-registry-metadata.mjs --check",
+    "sync-registry-metadata": "node scripts/sync-registry-metadata.mjs",
+    "update-readme": "node scripts/update-readme-tools.mjs"
   }
 }