@firfi/huly-mcp 0.15.1 → 0.16.0

package/dist/index.cjs

@@ -151353,864 +151353,1215 @@ var InvalidContentTypeError = class extends Schema_exports.TaggedError()(
   }
 };
 
-// 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)
+// 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 formatCandidates = (candidates) => candidates.map((candidate) => {
-  const name = candidate.name === void 0 ? "" : `${candidate.name} `;
-  const classes = candidate.sourceClass === void 0 || candidate.targetClass === void 0 ? "" : ` ${candidate.sourceClass} -> ${candidate.targetClass}`;
-  return `${name}(${candidate.id}${classes})`;
-}).join("; ");
-var AssociationNotFoundError = class extends Schema_exports.TaggedError()(
-  "AssociationNotFoundError",
-  {
-    identifier: Schema_exports.String
-  }
-) {
-  get message() {
-    return `Association '${this.identifier}' not found. Call list_associations to discover valid association IDs.`;
-  }
-};
-var AssociationIdentifierAmbiguousError = class extends Schema_exports.TaggedError()(
-  "AssociationIdentifierAmbiguousError",
-  {
-    identifier: Schema_exports.String,
-    candidates: Schema_exports.Array(CandidateSchema)
-  }
-) {
-  get message() {
-    return `Association '${this.identifier}' matched multiple definitions: ${formatCandidates(this.candidates)}. Call list_associations with sourceClass and targetClass to choose one.`;
-  }
-};
-var RelationNotFoundError = class extends Schema_exports.TaggedError()(
-  "RelationNotFoundError",
-  {
-    identifier: Schema_exports.String
-  }
-) {
-  get message() {
-    return `Relation '${this.identifier}' not found.`;
-  }
-};
-var RelationIdentifierAmbiguousError = class extends Schema_exports.TaggedError()(
-  "RelationIdentifierAmbiguousError",
-  {
-    identifier: Schema_exports.String,
-    relationIds: Schema_exports.Array(RelationId)
-  }
-) {
-  get message() {
-    return `Relation selector '${this.identifier}' matched multiple relations: ${this.relationIds.join(", ")}. Delete by relation ID instead.`;
-  }
-};
-var RelationMutationUnsupportedError = class extends Schema_exports.TaggedError()(
-  "RelationMutationUnsupportedError",
-  {
-    associationId: Schema_exports.optional(AssociationId),
-    reason: Schema_exports.String
-  }
-) {
-  get message() {
-    const id = this.associationId === void 0 ? "" : ` for association '${this.associationId}'`;
-    return `Generic relation mutation${id} is not supported: ${this.reason}. Call list_associations with writableOnly=true to discover writable associations.`;
-  }
-};
-var RelationEndpointClassMismatchError = class extends Schema_exports.TaggedError()(
-  "RelationEndpointClassMismatchError",
-  {
-    field: Schema_exports.String,
-    expectedClass: Schema_exports.String,
-    actualClass: Schema_exports.String
-  }
-) {
-  get message() {
-    return `Relation endpoint '${this.field}' has class '${this.actualClass}', expected '${this.expectedClass}'.`;
-  }
-};
-var GenericObjectIdentifierAmbiguousError = class extends Schema_exports.TaggedError()(
-  "GenericObjectIdentifierAmbiguousError",
-  {
-    field: Schema_exports.String,
-    identifier: Schema_exports.String,
-    candidates: Schema_exports.Array(Schema_exports.Struct({
-      id: DocId,
-      class: ObjectClassName,
-      display: Schema_exports.String
-    }))
-  }
-) {
-  get message() {
-    const candidates = this.candidates.map((candidate) => `${candidate.display} (${candidate.id}, ${candidate.class})`).join("; ");
-    return `Object locator '${this.field}' for '${this.identifier}' is ambiguous. Use a raw locator with one of these IDs: ${candidates}`;
-  }
-};
-var GenericObjectLocatorInvalidError = class extends Schema_exports.TaggedError()(
-  "GenericObjectLocatorInvalidError",
-  {
-    field: Schema_exports.String,
-    reason: Schema_exports.String
-  }
-) {
-  get message() {
-    return `Object locator '${this.field}' is invalid: ${this.reason}`;
-  }
-};
-var GenericObjectNotFoundError = class extends Schema_exports.TaggedError()(
-  "GenericObjectNotFoundError",
-  {
-    field: Schema_exports.String,
-    identifier: Schema_exports.String,
-    class: Schema_exports.optional(Schema_exports.String)
-  }
-) {
-  get message() {
-    const classHint = this.class === void 0 ? "" : ` with class '${this.class}'`;
-    return `Object locator '${this.field}' for '${this.identifier}'${classHint} not found.`;
-  }
-};
-
-// src/huly/errors-labels.ts
-var TagNotFoundError = class extends Schema_exports.TaggedError()(
-  "TagNotFoundError",
-  {
-    identifier: Schema_exports.String
-  }
-) {
-  get message() {
-    return `Tag/label '${this.identifier}' not found`;
-  }
-};
-var TagCategoryNotFoundError = class extends Schema_exports.TaggedError()(
-  "TagCategoryNotFoundError",
-  {
-    identifier: Schema_exports.String
-  }
-) {
-  get message() {
-    return `Tag category '${this.identifier}' not found`;
-  }
-};
-
-// src/domain/schemas/leads.ts
-var FunnelReference = NonEmptyString2.pipe(Schema_exports.brand("FunnelReference"));
-var FunnelIdentifier = DocId.pipe(Schema_exports.brand("FunnelIdentifier"));
-var CanonicalLeadIdentifier = Schema_exports.Trim.pipe(
-  Schema_exports.pattern(/^LEAD-\d+$/, {
-    message: () => "Expected lead identifier like 'LEAD-1'"
+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"
   }),
-  Schema_exports.brand("LeadIdentifier")
-);
-var leadIdentifierPattern = /^(?:LEAD-)?(\d+)$/i;
-var LeadIdentifier = Schema_exports.transformOrFail(Schema_exports.String, CanonicalLeadIdentifier, {
-  strict: true,
-  decode: (input, _options, ast) => {
-    const match16 = leadIdentifierPattern.exec(input.trim());
-    return match16 !== null ? ParseResult_exports.succeed(`LEAD-${match16[1]}`) : ParseResult_exports.fail(new ParseResult_exports.Type(ast, input, "Expected lead identifier like 'LEAD-1'"));
-  },
-  encode: ParseResult_exports.succeed
-}).annotations({
-  jsonSchema: {
-    type: "string",
-    pattern: "^LEAD-[0-9]+$"
-  }
+  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 FunnelSummarySchema = Schema_exports.Struct({
-  identifier: FunnelIdentifier,
-  name: Schema_exports.String,
-  description: Schema_exports.optional(Schema_exports.String),
-  archived: Schema_exports.Boolean
-}).annotations({
-  title: "FunnelSummary",
-  description: "Sales funnel summary"
+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 LeadSummarySchema = Schema_exports.Struct({
-  identifier: LeadIdentifier,
-  title: Schema_exports.String,
-  status: StatusName,
-  assignee: Schema_exports.optional(PersonName),
-  customer: Schema_exports.optional(Schema_exports.String),
-  modifiedOn: Schema_exports.optional(Timestamp)
-}).annotations({
-  title: "LeadSummary",
-  description: "Lead summary for list operations"
+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 LeadDetailSchema = Schema_exports.Struct({
-  identifier: LeadIdentifier,
-  title: Schema_exports.String,
-  description: Schema_exports.optional(Schema_exports.String),
-  status: StatusName,
-  assignee: Schema_exports.optional(PersonName),
-  customer: Schema_exports.optional(Schema_exports.String),
-  funnel: FunnelIdentifier,
-  funnelName: Schema_exports.String,
-  modifiedOn: Schema_exports.optional(Timestamp),
-  createdOn: Schema_exports.optional(Timestamp)
-}).annotations({
-  title: "LeadDetail",
-  description: "Full lead with all fields"
+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 ListFunnelsParamsSchema = Schema_exports.Struct({
-  includeArchived: Schema_exports.optional(Schema_exports.Boolean.annotations({
-    description: "Include archived funnels in results (default: false, showing only active)"
-  })),
-  limit: Schema_exports.optional(
-    LimitParam.annotations({
-      description: "Maximum number of funnels to return (default: 50)"
-    })
-  )
-}).annotations({
-  title: "ListFunnelsParams",
-  description: "Parameters for listing funnels"
+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 ListLeadsParamsBase = Schema_exports.Struct({
-  funnel: FunnelReference.annotations({
-    description: "Funnel ID returned by list_funnels, or funnel name for convenience lookup."
+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."
   }),
-  status: Schema_exports.optional(StatusName.annotations({
-    description: "Filter by status name"
+  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."
   })),
-  assignee: Schema_exports.optional(PersonRefInput.annotations({
-    description: "Filter by assignee email or display name"
+  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."
   })),
-  titleSearch: Schema_exports.optional(Schema_exports.String.annotations({
-    description: "Search leads by title substring (case-insensitive)"
+  source: Schema_exports.optional(GenericObjectLocatorSchema.annotations({
+    description: "Optional source endpoint filter"
   })),
-  limit: Schema_exports.optional(
-    LimitParam.annotations({
-      description: "Maximum number of leads to return (default: 50)"
-    })
+  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 ListLeadsParamsSchema = ListLeadsParamsBase.annotations({
-  title: "ListLeadsParams",
-  description: "Parameters for listing leads in a funnel"
+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 GetLeadParamsSchema = Schema_exports.Struct({
-  funnel: FunnelReference.annotations({
-    description: "Funnel ID returned by list_funnels, or funnel name for convenience lookup."
+var CreateRelationParamsSchema = Schema_exports.Struct({
+  association: AssociationIdentifier.annotations({
+    description: "Association _id or unambiguous name returned by list_associations"
   }),
-  identifier: LeadIdentifier.annotations({
-    description: "Lead identifier (e.g., 'LEAD-1')"
+  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: "GetLeadParams",
-  description: "Parameters for getting a single lead"
+  title: "DeleteRelationByIdParams",
+  description: "Delete one concrete relation by its relation ID."
 });
-var listFunnelsParamsJsonSchema = JSONSchema_exports.make(ListFunnelsParamsSchema);
-var listLeadsParamsJsonSchema = JSONSchema_exports.make(ListLeadsParamsSchema);
-var getLeadParamsJsonSchema = JSONSchema_exports.make(GetLeadParamsSchema);
-var parseListFunnelsParams = Schema_exports.decodeUnknown(ListFunnelsParamsSchema);
-var parseListLeadsParams = Schema_exports.decodeUnknown(ListLeadsParamsSchema);
-var parseGetLeadParams = Schema_exports.decodeUnknown(GetLeadParamsSchema);
-var parseLeadDetail = Schema_exports.decodeUnknown(LeadDetailSchema);
-var parseLeadSummary = Schema_exports.decodeUnknown(LeadSummarySchema);
+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-leads.ts
-var FunnelNotFoundError = class extends Schema_exports.TaggedError()(
-  "FunnelNotFoundError",
+// src/huly/errors-generic-associations.ts
+var CandidateSchema = Schema_exports.Struct({
+  id: AssociationId,
+  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} `;
+  const classes = candidate.sourceClass === void 0 || candidate.targetClass === void 0 ? "" : ` ${candidate.sourceClass} -> ${candidate.targetClass}`;
+  return `${name}(${candidate.id}${classes})`;
+}).join("; ");
+var AssociationNotFoundError = class extends Schema_exports.TaggedError()(
+  "AssociationNotFoundError",
   {
-    identifier: FunnelReference
+    identifier: Schema_exports.String
   }
 ) {
   get message() {
-    return `Funnel '${this.identifier}' not found`;
+    return `Association '${this.identifier}' not found. Call list_associations to discover valid association IDs.`;
   }
 };
-var LeadNotFoundError = class extends Schema_exports.TaggedError()(
-  "LeadNotFoundError",
+var AssociationIdentifierAmbiguousError = class extends Schema_exports.TaggedError()(
+  "AssociationIdentifierAmbiguousError",
   {
-    identifier: LeadIdentifier,
-    funnel: FunnelIdentifier
+    identifier: Schema_exports.String,
+    candidates: Schema_exports.Array(CandidateSchema)
   }
 ) {
   get message() {
-    return `Lead '${this.identifier}' not found in funnel '${this.funnel}'`;
+    return `Association '${this.identifier}' matched multiple definitions: ${formatCandidates(this.candidates)}. Call list_associations with sourceClass and targetClass to choose one.`;
   }
 };
-
-// src/huly/errors-messaging.ts
-var MIN_AMBIGUOUS_DM_MATCHES = 2;
-var ChannelNotFoundError = class extends Schema_exports.TaggedError()(
-  "ChannelNotFoundError",
+var RelationNotFoundError = class extends Schema_exports.TaggedError()(
+  "RelationNotFoundError",
   {
     identifier: Schema_exports.String
   }
 ) {
   get message() {
-    return `Channel '${this.identifier}' not found`;
+    return `Relation '${this.identifier}' not found.`;
   }
 };
-var DirectMessageNotFoundError = class extends Schema_exports.TaggedError()(
-  "DirectMessageNotFoundError",
+var RelationIdentifierAmbiguousError = class extends Schema_exports.TaggedError()(
+  "RelationIdentifierAmbiguousError",
   {
-    identifier: Schema_exports.String
+    identifier: Schema_exports.String,
+    relationIds: Schema_exports.Array(RelationId)
   }
 ) {
   get message() {
-    return `Direct message '${this.identifier}' not found`;
+    return `Relation selector '${this.identifier}' matched multiple relations: ${this.relationIds.join(", ")}. Delete by relation ID instead.`;
   }
 };
-var DirectMessageIdentifierAmbiguousError = class extends Schema_exports.TaggedError()(
-  "DirectMessageIdentifierAmbiguousError",
+var RelationMutationUnsupportedError = class extends Schema_exports.TaggedError()(
+  "RelationMutationUnsupportedError",
   {
-    identifier: Schema_exports.String,
-    matches: Schema_exports.Number.pipe(Schema_exports.int(), Schema_exports.greaterThanOrEqualTo(MIN_AMBIGUOUS_DM_MATCHES))
+    associationId: Schema_exports.optional(AssociationId),
+    reason: Schema_exports.String
   }
 ) {
   get message() {
-    return `Direct message '${this.identifier}' is ambiguous (${this.matches} matches); use the DM _id`;
+    const id = this.associationId === void 0 ? "" : ` for association '${this.associationId}'`;
+    return `Generic relation mutation${id} is not supported: ${this.reason}. Call list_associations with writableOnly=true to discover writable associations.`;
   }
 };
-var CannotDirectMessageSelfError = class extends Schema_exports.TaggedError()(
-  "CannotDirectMessageSelfError",
+var AssociationSystemClassUnsupportedError = class extends Schema_exports.TaggedError()(
+  "AssociationSystemClassUnsupportedError",
   {
-    identifier: Schema_exports.String
+    className: ObjectClassName,
+    operation: Schema_exports.Literal("create_association", "delete_association", "create_relation", "delete_relation")
   }
 ) {
   get message() {
-    return `Cannot start a direct-message conversation with yourself ('${this.identifier}')`;
+    return `${this.operation} does not support core system class '${this.className}' in generic association writes.`;
   }
 };
-var PersonNotAnEmployeeError = class extends Schema_exports.TaggedError()(
-  "PersonNotAnEmployeeError",
+var AssociationConflictError = class extends Schema_exports.TaggedError()(
+  "AssociationConflictError",
   {
-    identifier: Schema_exports.String
+    associationId: AssociationId,
+    reason: Schema_exports.String
   }
 ) {
   get message() {
-    return `Person '${this.identifier}' is not a workspace member (no Huly account) and cannot receive direct messages`;
+    return `Association '${this.associationId}' already exists but conflicts with the requested definition: ${this.reason}.`;
   }
 };
-var MessageNotFoundError = class extends Schema_exports.TaggedError()(
-  "MessageNotFoundError",
+var AssociationInUseError = class extends Schema_exports.TaggedError()(
+  "AssociationInUseError",
   {
-    messageId: Schema_exports.String,
-    channel: Schema_exports.String
+    associationId: AssociationId,
+    relationCount: Schema_exports.Number,
+    sampleRelationIds: Schema_exports.Array(RelationId)
   }
 ) {
   get message() {
-    return `Message '${this.messageId}' not found in channel '${this.channel}'`;
+    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 ThreadReplyNotFoundError = class extends Schema_exports.TaggedError()(
-  "ThreadReplyNotFoundError",
+var RelationCardinalityViolationError = class extends Schema_exports.TaggedError()(
+  "RelationCardinalityViolationError",
   {
-    replyId: Schema_exports.String,
-    messageId: Schema_exports.String
+    associationId: AssociationId,
+    cardinality: CardinalitySchema,
+    reason: Schema_exports.String
   }
 ) {
   get message() {
-    return `Thread reply '${this.replyId}' not found on message '${this.messageId}'`;
+    return `Relation violates ${this.cardinality} cardinality for association '${this.associationId}': ${this.reason}.`;
   }
 };
-var ActivityMessageNotFoundError = class extends Schema_exports.TaggedError()(
-  "ActivityMessageNotFoundError",
+var RelationDirectionAmbiguousError = class extends Schema_exports.TaggedError()(
+  "RelationDirectionAmbiguousError",
   {
-    messageId: Schema_exports.String
+    associationId: AssociationId,
+    reason: Schema_exports.String
   }
 ) {
   get message() {
-    return `Activity message '${this.messageId}' not found`;
+    return `Relation direction is ambiguous for association '${this.associationId}': ${this.reason}. Use source-to-target or target-to-source.`;
   }
 };
-var ReactionNotFoundError = class extends Schema_exports.TaggedError()(
-  "ReactionNotFoundError",
+var RelationEndpointClassMismatchError = class extends Schema_exports.TaggedError()(
+  "RelationEndpointClassMismatchError",
   {
-    messageId: Schema_exports.String,
-    emoji: Schema_exports.String
+    field: Schema_exports.String,
+    expectedClass: Schema_exports.String,
+    actualClass: Schema_exports.String
   }
 ) {
   get message() {
-    return `Reaction '${this.emoji}' not found on message '${this.messageId}'`;
+    return `Relation endpoint '${this.field}' has class '${this.actualClass}', expected '${this.expectedClass}'.`;
   }
 };
-var SavedMessageNotFoundError = class extends Schema_exports.TaggedError()(
-  "SavedMessageNotFoundError",
+var GenericObjectIdentifierAmbiguousError = class extends Schema_exports.TaggedError()(
+  "GenericObjectIdentifierAmbiguousError",
   {
-    messageId: Schema_exports.String
+    field: Schema_exports.String,
+    identifier: Schema_exports.String,
+    candidates: Schema_exports.Array(Schema_exports.Struct({
+      id: DocId,
+      class: ObjectClassName,
+      display: Schema_exports.String
+    }))
   }
 ) {
   get message() {
-    return `Saved message for '${this.messageId}' not found`;
+    const candidates = this.candidates.map((candidate) => `${candidate.display} (${candidate.id}, ${candidate.class})`).join("; ");
+    return `Object locator '${this.field}' for '${this.identifier}' is ambiguous. Use a raw locator with one of these IDs: ${candidates}`;
+  }
+};
+var GenericObjectLocatorInvalidError = class extends Schema_exports.TaggedError()(
+  "GenericObjectLocatorInvalidError",
+  {
+    field: Schema_exports.String,
+    reason: Schema_exports.String
+  }
+) {
+  get message() {
+    return `Object locator '${this.field}' is invalid: ${this.reason}`;
+  }
+};
+var GenericObjectNotFoundError = class extends Schema_exports.TaggedError()(
+  "GenericObjectNotFoundError",
+  {
+    field: Schema_exports.String,
+    identifier: Schema_exports.String,
+    class: Schema_exports.optional(Schema_exports.String)
+  }
+) {
+  get message() {
+    const classHint = this.class === void 0 ? "" : ` with class '${this.class}'`;
+    return `Object locator '${this.field}' for '${this.identifier}'${classHint} not found.`;
   }
 };
 
-// src/huly/errors-notifications.ts
-var NotificationNotFoundError = class extends Schema_exports.TaggedError()(
-  "NotificationNotFoundError",
+// src/huly/errors-labels.ts
+var TagNotFoundError = class extends Schema_exports.TaggedError()(
+  "TagNotFoundError",
   {
-    notificationId: Schema_exports.String
+    identifier: Schema_exports.String
   }
 ) {
   get message() {
-    return `Notification '${this.notificationId}' not found`;
+    return `Tag/label '${this.identifier}' not found`;
   }
 };
-var NotificationContextNotFoundError = class extends Schema_exports.TaggedError()(
-  "NotificationContextNotFoundError",
+var TagCategoryNotFoundError = class extends Schema_exports.TaggedError()(
+  "TagCategoryNotFoundError",
   {
-    contextId: Schema_exports.String
+    identifier: Schema_exports.String
   }
 ) {
   get message() {
-    return `Notification context '${this.contextId}' not found`;
+    return `Tag category '${this.identifier}' not found`;
   }
 };
 
-// src/domain/schemas/processes.ts
-var ProcessId = DocId.pipe(Schema_exports.brand("ProcessId"));
-var ProcessIdentifier = NonEmptyString2.pipe(Schema_exports.brand("ProcessIdentifier"));
-var ProcessExecutionId = DocId.pipe(Schema_exports.brand("ProcessExecutionId"));
-var ProcessStateId = DocId.pipe(Schema_exports.brand("ProcessStateId"));
-var ProcessTransitionId = DocId.pipe(Schema_exports.brand("ProcessTransitionId"));
-var ProcessCardIdentifier = NonEmptyString2.pipe(Schema_exports.brand("ProcessCardIdentifier"));
-var ProcessMasterTagIdentifier = NonEmptyString2.pipe(Schema_exports.brand("ProcessMasterTagIdentifier"));
-var ProcessExecutionStatusSchema = Schema_exports.Literal("active", "done", "cancelled");
-var ProcessCandidateSchema = Schema_exports.Struct({
-  id: ProcessId,
-  name: NonEmptyString2,
-  masterTagId: MasterTagId,
-  masterTagName: Schema_exports.optional(NonEmptyString2)
+// src/domain/schemas/leads.ts
+var FunnelReference = NonEmptyString2.pipe(Schema_exports.brand("FunnelReference"));
+var FunnelIdentifier = DocId.pipe(Schema_exports.brand("FunnelIdentifier"));
+var CanonicalLeadIdentifier = Schema_exports.Trim.pipe(
+  Schema_exports.pattern(/^LEAD-\d+$/, {
+    message: () => "Expected lead identifier like 'LEAD-1'"
+  }),
+  Schema_exports.brand("LeadIdentifier")
+);
+var leadIdentifierPattern = /^(?:LEAD-)?(\d+)$/i;
+var LeadIdentifier = Schema_exports.transformOrFail(Schema_exports.String, CanonicalLeadIdentifier, {
+  strict: true,
+  decode: (input, _options, ast) => {
+    const match16 = leadIdentifierPattern.exec(input.trim());
+    return match16 !== null ? ParseResult_exports.succeed(`LEAD-${match16[1]}`) : ParseResult_exports.fail(new ParseResult_exports.Type(ast, input, "Expected lead identifier like 'LEAD-1'"));
+  },
+  encode: ParseResult_exports.succeed
+}).annotations({
+  jsonSchema: {
+    type: "string",
+    pattern: "^LEAD-[0-9]+$"
+  }
 });
-var ProcessSummarySchema = Schema_exports.Struct({
-  id: ProcessId,
-  name: NonEmptyString2,
+var FunnelSummarySchema = Schema_exports.Struct({
+  identifier: FunnelIdentifier,
+  name: Schema_exports.String,
   description: Schema_exports.optional(Schema_exports.String),
-  masterTagId: MasterTagId,
-  masterTagName: Schema_exports.optional(NonEmptyString2),
-  autoStart: Schema_exports.Boolean,
-  automationOnly: Schema_exports.Boolean,
-  parallelExecutionForbidden: Schema_exports.Boolean,
-  stateCount: Schema_exports.NonNegativeInt,
-  transitionCount: Schema_exports.NonNegativeInt
-});
-var ProcessStateSummarySchema = Schema_exports.Struct({
-  id: ProcessStateId,
-  title: NonEmptyString2
-});
-var ProcessTransitionSummarySchema = Schema_exports.Struct({
-  id: ProcessTransitionId,
-  fromStateId: Schema_exports.optional(ProcessStateId),
-  fromStateTitle: Schema_exports.optional(NonEmptyString2),
-  toStateId: ProcessStateId,
-  toStateTitle: Schema_exports.optional(NonEmptyString2),
-  triggerId: NonEmptyString2,
-  actionCount: Schema_exports.NonNegativeInt
+  archived: Schema_exports.Boolean
+}).annotations({
+  title: "FunnelSummary",
+  description: "Sales funnel summary"
 });
-var ProcessDetailSchema = ProcessSummarySchema.pipe(
-  Schema_exports.extend(Schema_exports.Struct({
-    initialStateId: Schema_exports.optional(ProcessStateId),
-    states: Schema_exports.Array(ProcessStateSummarySchema),
-    transitions: Schema_exports.Array(ProcessTransitionSummarySchema)
-  }))
-);
-var ProcessExecutionSummarySchema = Schema_exports.Struct({
-  id: ProcessExecutionId,
-  processId: ProcessId,
-  processName: Schema_exports.optional(NonEmptyString2),
-  cardId: CardId,
-  cardTitle: Schema_exports.optional(NonEmptyString2),
-  currentStateId: ProcessStateId,
-  currentStateTitle: Schema_exports.optional(NonEmptyString2),
-  status: ProcessExecutionStatusSchema,
-  errorCount: Schema_exports.NonNegativeInt,
-  hasError: Schema_exports.Boolean,
-  hasParent: Schema_exports.Boolean,
-  parentExecutionId: Schema_exports.optional(ProcessExecutionId),
+var LeadSummarySchema = Schema_exports.Struct({
+  identifier: LeadIdentifier,
+  title: Schema_exports.String,
+  status: StatusName,
+  assignee: Schema_exports.optional(PersonName),
+  customer: Schema_exports.optional(Schema_exports.String),
   modifiedOn: Schema_exports.optional(Timestamp)
-});
-var ListProcessesParamsSchema = Schema_exports.Struct({
-  masterTag: Schema_exports.optional(ProcessMasterTagIdentifier.annotations({
-    description: "Optional master tag/card type ID or display label. Use this when you only want workflows attached to one Huly card/document type."
-  })),
-  limit: Schema_exports.optional(LimitParam.annotations({
-    description: "Maximum number of process definitions to return (default: 50, maximum: 200)."
-  }))
 }).annotations({
-  title: "ListProcessesParams",
-  description: "Parameters for listing Huly Process workflow definitions."
+  title: "LeadSummary",
+  description: "Lead summary for list operations"
 });
-var GetProcessParamsSchema = Schema_exports.Struct({
-  process: ProcessIdentifier.annotations({
-    description: "Process/workflow ID or exact display name. Ambiguous names fail with candidate IDs instead of guessing."
-  })
+var LeadDetailSchema = Schema_exports.Struct({
+  identifier: LeadIdentifier,
+  title: Schema_exports.String,
+  description: Schema_exports.optional(Schema_exports.String),
+  status: StatusName,
+  assignee: Schema_exports.optional(PersonName),
+  customer: Schema_exports.optional(Schema_exports.String),
+  funnel: FunnelIdentifier,
+  funnelName: Schema_exports.String,
+  modifiedOn: Schema_exports.optional(Timestamp),
+  createdOn: Schema_exports.optional(Timestamp)
 }).annotations({
-  title: "GetProcessParams",
-  description: "Parameters for retrieving one Huly Process workflow definition."
+  title: "LeadDetail",
+  description: "Full lead with all fields"
 });
-var ListExecutionsParamsSchema = Schema_exports.Struct({
-  process: Schema_exports.optional(ProcessIdentifier.annotations({
-    description: "Optional process/workflow ID or exact display name. Ambiguous names fail with candidate IDs instead of guessing."
-  })),
-  card: Schema_exports.optional(ProcessCardIdentifier.annotations({
-    description: "Optional card/document ID or exact title. If a title matches multiple cards, the call fails with candidates."
-  })),
-  status: Schema_exports.optional(ProcessExecutionStatusSchema.annotations({
-    description: "Optional execution status filter: active, done, or cancelled."
+var ListFunnelsParamsSchema = Schema_exports.Struct({
+  includeArchived: Schema_exports.optional(Schema_exports.Boolean.annotations({
+    description: "Include archived funnels in results (default: false, showing only active)"
   })),
-  limit: Schema_exports.optional(LimitParam.annotations({
-    description: "Maximum number of executions to return (default: 50, maximum: 200)."
-  }))
+  limit: Schema_exports.optional(
+    LimitParam.annotations({
+      description: "Maximum number of funnels to return (default: 50)"
+    })
+  )
 }).annotations({
-  title: "ListExecutionsParams",
-  description: "Parameters for listing read-only Huly Process workflow executions."
+  title: "ListFunnelsParams",
+  description: "Parameters for listing funnels"
 });
-var StartProcessParamsSchema = Schema_exports.Struct({
-  process: ProcessIdentifier.annotations({
-    description: "Process/workflow ID or exact display name. Ambiguous names fail with candidate IDs instead of guessing."
+var ListLeadsParamsBase = Schema_exports.Struct({
+  funnel: FunnelReference.annotations({
+    description: "Funnel ID returned by list_funnels, or funnel name for convenience lookup."
   }),
-  card: ProcessCardIdentifier.annotations({
-    description: "Card/document ID or exact title to attach the new execution to. If a title matches multiple cards, the call fails with candidates."
-  })
-}).annotations({
-  title: "StartProcessParams",
-  description: "Parameters for starting a Huly Process workflow execution on a card/document."
+  status: Schema_exports.optional(StatusName.annotations({
+    description: "Filter by status name"
+  })),
+  assignee: Schema_exports.optional(PersonRefInput.annotations({
+    description: "Filter by assignee email or display name"
+  })),
+  titleSearch: Schema_exports.optional(Schema_exports.String.annotations({
+    description: "Search leads by title substring (case-insensitive)"
+  })),
+  limit: Schema_exports.optional(
+    LimitParam.annotations({
+      description: "Maximum number of leads to return (default: 50)"
+    })
+  )
 });
-var CancelExecutionParamsSchema = Schema_exports.Struct({
-  execution: ProcessExecutionId.annotations({
-    description: "Process execution ID to cancel. Already-cancelled executions return cancelled=false; completed executions fail without mutation."
+var ListLeadsParamsSchema = ListLeadsParamsBase.annotations({
+  title: "ListLeadsParams",
+  description: "Parameters for listing leads in a funnel"
+});
+var GetLeadParamsSchema = Schema_exports.Struct({
+  funnel: FunnelReference.annotations({
+    description: "Funnel ID returned by list_funnels, or funnel name for convenience lookup."
+  }),
+  identifier: LeadIdentifier.annotations({
+    description: "Lead identifier (e.g., 'LEAD-1')"
   })
 }).annotations({
-  title: "CancelExecutionParams",
-  description: "Parameters for cancelling an active Huly Process workflow execution."
-});
-var ListProcessesResultSchema = Schema_exports.Struct({
-  processes: Schema_exports.Array(ProcessSummarySchema),
-  total: Schema_exports.NonNegativeInt
-});
-var ListExecutionsResultSchema = Schema_exports.Struct({
-  executions: Schema_exports.Array(ProcessExecutionSummarySchema),
-  total: Schema_exports.NonNegativeInt
-});
-var StartProcessResultSchema = Schema_exports.Struct({
-  executionId: ProcessExecutionId,
-  processId: ProcessId,
-  processName: Schema_exports.optional(NonEmptyString2),
-  cardId: CardId,
-  cardTitle: Schema_exports.optional(NonEmptyString2),
-  currentStateId: ProcessStateId,
-  currentStateTitle: Schema_exports.optional(NonEmptyString2),
-  status: Schema_exports.Literal("active")
-});
-var CancelExecutionResultSchema = Schema_exports.Struct({
-  executionId: ProcessExecutionId,
-  status: Schema_exports.Literal("cancelled"),
-  cancelled: Schema_exports.Boolean
+  title: "GetLeadParams",
+  description: "Parameters for getting a single lead"
 });
-var listProcessesParamsJsonSchema = JSONSchema_exports.make(ListProcessesParamsSchema);
-var getProcessParamsJsonSchema = JSONSchema_exports.make(GetProcessParamsSchema);
-var listExecutionsParamsJsonSchema = JSONSchema_exports.make(ListExecutionsParamsSchema);
-var startProcessParamsJsonSchema = JSONSchema_exports.make(StartProcessParamsSchema);
-var cancelExecutionParamsJsonSchema = JSONSchema_exports.make(CancelExecutionParamsSchema);
-var parseListProcessesParams = Schema_exports.decodeUnknown(ListProcessesParamsSchema);
-var parseGetProcessParams = Schema_exports.decodeUnknown(GetProcessParamsSchema);
-var parseListExecutionsParams = Schema_exports.decodeUnknown(ListExecutionsParamsSchema);
-var parseStartProcessParams = Schema_exports.decodeUnknown(StartProcessParamsSchema);
-var parseCancelExecutionParams = Schema_exports.decodeUnknown(CancelExecutionParamsSchema);
+var listFunnelsParamsJsonSchema = JSONSchema_exports.make(ListFunnelsParamsSchema);
+var listLeadsParamsJsonSchema = JSONSchema_exports.make(ListLeadsParamsSchema);
+var getLeadParamsJsonSchema = JSONSchema_exports.make(GetLeadParamsSchema);
+var parseListFunnelsParams = Schema_exports.decodeUnknown(ListFunnelsParamsSchema);
+var parseListLeadsParams = Schema_exports.decodeUnknown(ListLeadsParamsSchema);
+var parseGetLeadParams = Schema_exports.decodeUnknown(GetLeadParamsSchema);
+var parseLeadDetail = Schema_exports.decodeUnknown(LeadDetailSchema);
+var parseLeadSummary = Schema_exports.decodeUnknown(LeadSummarySchema);
 
-// src/huly/errors-processes.ts
-var candidateList = (candidates) => candidates.map(
-  (candidate) => candidate.masterTagName === void 0 ? `${candidate.name} (${candidate.id}, masterTag ${candidate.masterTagId})` : `${candidate.name} (${candidate.id}, ${candidate.masterTagName})`
-).join("; ");
-var ProcessNotFoundError = class extends Schema_exports.TaggedError()(
-  "ProcessNotFoundError",
+// src/huly/errors-leads.ts
+var FunnelNotFoundError = class extends Schema_exports.TaggedError()(
+  "FunnelNotFoundError",
   {
-    identifier: Schema_exports.String,
-    candidates: Schema_exports.Array(ProcessCandidateSchema)
+    identifier: FunnelReference
   }
 ) {
   get message() {
-    const suffix = this.candidates.length === 0 ? "" : ` Available processes: ${candidateList(this.candidates)}`;
-    return `Process '${this.identifier}' not found.${suffix}`;
+    return `Funnel '${this.identifier}' not found`;
   }
 };
-var ProcessIdentifierAmbiguousError = class extends Schema_exports.TaggedError()(
-  "ProcessIdentifierAmbiguousError",
+var LeadNotFoundError = class extends Schema_exports.TaggedError()(
+  "LeadNotFoundError",
   {
-    identifier: Schema_exports.String,
-    candidates: Schema_exports.Array(ProcessCandidateSchema)
+    identifier: LeadIdentifier,
+    funnel: FunnelIdentifier
   }
 ) {
   get message() {
-    return `Process name '${this.identifier}' is ambiguous. Use one of these process IDs: ${candidateList(this.candidates)}`;
+    return `Lead '${this.identifier}' not found in funnel '${this.funnel}'`;
   }
 };
-var ProcessMasterTagNotFoundError = class extends Schema_exports.TaggedError()(
-  "ProcessMasterTagNotFoundError",
+
+// src/huly/errors-messaging.ts
+var MIN_AMBIGUOUS_DM_MATCHES = 2;
+var ChannelNotFoundError = class extends Schema_exports.TaggedError()(
+  "ChannelNotFoundError",
   {
     identifier: Schema_exports.String
   }
 ) {
   get message() {
-    return `Process master tag/card type '${this.identifier}' not found`;
+    return `Channel '${this.identifier}' not found`;
   }
 };
-var ProcessMasterTagAmbiguousError = class extends Schema_exports.TaggedError()(
-  "ProcessMasterTagAmbiguousError",
+var DirectMessageNotFoundError = class extends Schema_exports.TaggedError()(
+  "DirectMessageNotFoundError",
   {
-    identifier: Schema_exports.String,
-    candidates: Schema_exports.Array(Schema_exports.Struct({
-      id: MasterTagId,
-      name: NonEmptyString2
-    }))
+    identifier: Schema_exports.String
   }
 ) {
   get message() {
-    const candidates = this.candidates.map((candidate) => `${candidate.name} (${candidate.id})`).join("; ");
-    return `Process master tag/card type '${this.identifier}' is ambiguous. Use one of these IDs: ${candidates}`;
+    return `Direct message '${this.identifier}' not found`;
   }
 };
-var ProcessCardIdentifierAmbiguousError = class extends Schema_exports.TaggedError()(
-  "ProcessCardIdentifierAmbiguousError",
+var DirectMessageIdentifierAmbiguousError = class extends Schema_exports.TaggedError()(
+  "DirectMessageIdentifierAmbiguousError",
   {
     identifier: Schema_exports.String,
-    candidates: Schema_exports.Array(Schema_exports.Struct({
-      id: CardId,
-      title: NonEmptyString2
-    }))
+    matches: Schema_exports.Number.pipe(Schema_exports.int(), Schema_exports.greaterThanOrEqualTo(MIN_AMBIGUOUS_DM_MATCHES))
   }
 ) {
   get message() {
-    const candidates = this.candidates.map((candidate) => `${candidate.title} (${candidate.id})`).join("; ");
-    return `Card/document title '${this.identifier}' is ambiguous. Use one of these card IDs: ${candidates}`;
+    return `Direct message '${this.identifier}' is ambiguous (${this.matches} matches); use the DM _id`;
   }
 };
-var ProcessCardNotFoundError = class extends Schema_exports.TaggedError()(
-  "ProcessCardNotFoundError",
+var CannotDirectMessageSelfError = class extends Schema_exports.TaggedError()(
+  "CannotDirectMessageSelfError",
   {
     identifier: Schema_exports.String
   }
 ) {
   get message() {
-    return `Card/document '${this.identifier}' not found`;
-  }
-};
-var ProcessInitialStateNotFoundError = class extends Schema_exports.TaggedError()(
-  "ProcessInitialStateNotFoundError",
-  {
-    processId: ProcessId,
-    processName: NonEmptyString2
-  }
-) {
-  get message() {
-    return `Process '${this.processName}' (${this.processId}) has no initial transition from null`;
-  }
-};
-var ProcessParallelExecutionForbiddenError = class extends Schema_exports.TaggedError()(
-  "ProcessParallelExecutionForbiddenError",
-  {
-    processId: ProcessId,
-    cardId: CardId,
-    activeExecutionId: ProcessExecutionId
-  }
-) {
-  get message() {
-    return `Process '${this.processId}' already has active execution '${this.activeExecutionId}' for card '${this.cardId}'`;
+    return `Cannot start a direct-message conversation with yourself ('${this.identifier}')`;
   }
 };
-var ProcessExecutionNotFoundError = class extends Schema_exports.TaggedError()(
-  "ProcessExecutionNotFoundError",
+var PersonNotAnEmployeeError = class extends Schema_exports.TaggedError()(
+  "PersonNotAnEmployeeError",
   {
-    executionId: ProcessExecutionId
+    identifier: Schema_exports.String
   }
 ) {
   get message() {
-    return `Process execution '${this.executionId}' not found`;
+    return `Person '${this.identifier}' is not a workspace member (no Huly account) and cannot receive direct messages`;
   }
 };
-var ProcessExecutionNotCancellableError = class extends Schema_exports.TaggedError()(
-  "ProcessExecutionNotCancellableError",
+var MessageNotFoundError = class extends Schema_exports.TaggedError()(
+  "MessageNotFoundError",
   {
-    executionId: ProcessExecutionId,
-    status: Schema_exports.Literal("done")
+    messageId: Schema_exports.String,
+    channel: Schema_exports.String
   }
 ) {
   get message() {
-    return `Process execution '${this.executionId}' is completed and cannot be cancelled`;
+    return `Message '${this.messageId}' not found in channel '${this.channel}'`;
   }
 };
-
-// src/huly/errors-test-management.ts
-var TestProjectNotFoundError = class extends Schema_exports.TaggedError()(
-  "TestProjectNotFoundError",
+var ThreadReplyNotFoundError = class extends Schema_exports.TaggedError()(
+  "ThreadReplyNotFoundError",
   {
-    identifier: Schema_exports.String
+    replyId: Schema_exports.String,
+    messageId: Schema_exports.String
   }
 ) {
   get message() {
-    return `Test project '${this.identifier}' not found`;
+    return `Thread reply '${this.replyId}' not found on message '${this.messageId}'`;
   }
 };
-var TestSuiteNotFoundError = class extends Schema_exports.TaggedError()(
-  "TestSuiteNotFoundError",
+var ActivityMessageNotFoundError = class extends Schema_exports.TaggedError()(
+  "ActivityMessageNotFoundError",
   {
-    identifier: Schema_exports.String
+    messageId: Schema_exports.String
   }
 ) {
   get message() {
-    return `Test suite '${this.identifier}' not found`;
+    return `Activity message '${this.messageId}' not found`;
   }
 };
-var TestCaseNotFoundError = class extends Schema_exports.TaggedError()(
-  "TestCaseNotFoundError",
+var ReactionNotFoundError = class extends Schema_exports.TaggedError()(
+  "ReactionNotFoundError",
   {
-    identifier: Schema_exports.String
+    messageId: Schema_exports.String,
+    emoji: Schema_exports.String
   }
 ) {
   get message() {
-    return `Test case '${this.identifier}' not found`;
+    return `Reaction '${this.emoji}' not found on message '${this.messageId}'`;
   }
 };
-var TestPlanNotFoundError = class extends Schema_exports.TaggedError()(
-  "TestPlanNotFoundError",
+var SavedMessageNotFoundError = class extends Schema_exports.TaggedError()(
+  "SavedMessageNotFoundError",
   {
-    identifier: Schema_exports.String
+    messageId: Schema_exports.String
   }
 ) {
   get message() {
-    return `Test plan '${this.identifier}' not found`;
+    return `Saved message for '${this.messageId}' not found`;
   }
 };
-var TestRunNotFoundError = class extends Schema_exports.TaggedError()(
-  "TestRunNotFoundError",
+
+// src/huly/errors-notifications.ts
+var NotificationNotFoundError = class extends Schema_exports.TaggedError()(
+  "NotificationNotFoundError",
   {
-    identifier: Schema_exports.String
+    notificationId: Schema_exports.String
   }
 ) {
   get message() {
-    return `Test run '${this.identifier}' not found`;
+    return `Notification '${this.notificationId}' not found`;
   }
 };
-var TestResultNotFoundError = class extends Schema_exports.TaggedError()(
-  "TestResultNotFoundError",
+var NotificationContextNotFoundError = class extends Schema_exports.TaggedError()(
+  "NotificationContextNotFoundError",
   {
-    identifier: Schema_exports.String
+    contextId: Schema_exports.String
   }
 ) {
   get message() {
-    return `Test result '${this.identifier}' not found`;
-  }
-};
-var TestPlanItemNotFoundError = class extends Schema_exports.TaggedError()(
-  "TestPlanItemNotFoundError",
-  {
-    identifier: Schema_exports.String,
-    plan: Schema_exports.String
-  }
-) {
-  get message() {
-    return `Test plan item '${this.identifier}' not found in plan '${this.plan}'`;
+    return `Notification context '${this.contextId}' not found`;
   }
 };
 
-// src/huly/errors-tracker.ts
-var IssueNotFoundError = class extends Schema_exports.TaggedError()(
-  "IssueNotFoundError",
+// src/domain/schemas/processes.ts
+var ProcessId = DocId.pipe(Schema_exports.brand("ProcessId"));
+var ProcessIdentifier = NonEmptyString2.pipe(Schema_exports.brand("ProcessIdentifier"));
+var ProcessExecutionId = DocId.pipe(Schema_exports.brand("ProcessExecutionId"));
+var ProcessStateId = DocId.pipe(Schema_exports.brand("ProcessStateId"));
+var ProcessTransitionId = DocId.pipe(Schema_exports.brand("ProcessTransitionId"));
+var ProcessCardIdentifier = NonEmptyString2.pipe(Schema_exports.brand("ProcessCardIdentifier"));
+var ProcessMasterTagIdentifier = NonEmptyString2.pipe(Schema_exports.brand("ProcessMasterTagIdentifier"));
+var ProcessExecutionStatusSchema = Schema_exports.Literal("active", "done", "cancelled");
+var ProcessCandidateSchema = Schema_exports.Struct({
+  id: ProcessId,
+  name: NonEmptyString2,
+  masterTagId: MasterTagId,
+  masterTagName: Schema_exports.optional(NonEmptyString2)
+});
+var ProcessSummarySchema = Schema_exports.Struct({
+  id: ProcessId,
+  name: NonEmptyString2,
+  description: Schema_exports.optional(Schema_exports.String),
+  masterTagId: MasterTagId,
+  masterTagName: Schema_exports.optional(NonEmptyString2),
+  autoStart: Schema_exports.Boolean,
+  automationOnly: Schema_exports.Boolean,
+  parallelExecutionForbidden: Schema_exports.Boolean,
+  stateCount: Schema_exports.NonNegativeInt,
+  transitionCount: Schema_exports.NonNegativeInt
+});
+var ProcessStateSummarySchema = Schema_exports.Struct({
+  id: ProcessStateId,
+  title: NonEmptyString2
+});
+var ProcessTransitionSummarySchema = Schema_exports.Struct({
+  id: ProcessTransitionId,
+  fromStateId: Schema_exports.optional(ProcessStateId),
+  fromStateTitle: Schema_exports.optional(NonEmptyString2),
+  toStateId: ProcessStateId,
+  toStateTitle: Schema_exports.optional(NonEmptyString2),
+  triggerId: NonEmptyString2,
+  actionCount: Schema_exports.NonNegativeInt
+});
+var ProcessDetailSchema = ProcessSummarySchema.pipe(
+  Schema_exports.extend(Schema_exports.Struct({
+    initialStateId: Schema_exports.optional(ProcessStateId),
+    states: Schema_exports.Array(ProcessStateSummarySchema),
+    transitions: Schema_exports.Array(ProcessTransitionSummarySchema)
+  }))
+);
+var ProcessExecutionSummarySchema = Schema_exports.Struct({
+  id: ProcessExecutionId,
+  processId: ProcessId,
+  processName: Schema_exports.optional(NonEmptyString2),
+  cardId: CardId,
+  cardTitle: Schema_exports.optional(NonEmptyString2),
+  currentStateId: ProcessStateId,
+  currentStateTitle: Schema_exports.optional(NonEmptyString2),
+  status: ProcessExecutionStatusSchema,
+  errorCount: Schema_exports.NonNegativeInt,
+  hasError: Schema_exports.Boolean,
+  hasParent: Schema_exports.Boolean,
+  parentExecutionId: Schema_exports.optional(ProcessExecutionId),
+  modifiedOn: Schema_exports.optional(Timestamp)
+});
+var ListProcessesParamsSchema = Schema_exports.Struct({
+  masterTag: Schema_exports.optional(ProcessMasterTagIdentifier.annotations({
+    description: "Optional master tag/card type ID or display label. Use this when you only want workflows attached to one Huly card/document type."
+  })),
+  limit: Schema_exports.optional(LimitParam.annotations({
+    description: "Maximum number of process definitions to return (default: 50, maximum: 200)."
+  }))
+}).annotations({
+  title: "ListProcessesParams",
+  description: "Parameters for listing Huly Process workflow definitions."
+});
+var GetProcessParamsSchema = Schema_exports.Struct({
+  process: ProcessIdentifier.annotations({
+    description: "Process/workflow ID or exact display name. Ambiguous names fail with candidate IDs instead of guessing."
+  })
+}).annotations({
+  title: "GetProcessParams",
+  description: "Parameters for retrieving one Huly Process workflow definition."
+});
+var ListExecutionsParamsSchema = Schema_exports.Struct({
+  process: Schema_exports.optional(ProcessIdentifier.annotations({
+    description: "Optional process/workflow ID or exact display name. Ambiguous names fail with candidate IDs instead of guessing."
+  })),
+  card: Schema_exports.optional(ProcessCardIdentifier.annotations({
+    description: "Optional card/document ID or exact title. If a title matches multiple cards, the call fails with candidates."
+  })),
+  status: Schema_exports.optional(ProcessExecutionStatusSchema.annotations({
+    description: "Optional execution status filter: active, done, or cancelled."
+  })),
+  limit: Schema_exports.optional(LimitParam.annotations({
+    description: "Maximum number of executions to return (default: 50, maximum: 200)."
+  }))
+}).annotations({
+  title: "ListExecutionsParams",
+  description: "Parameters for listing read-only Huly Process workflow executions."
+});
+var StartProcessParamsSchema = Schema_exports.Struct({
+  process: ProcessIdentifier.annotations({
+    description: "Process/workflow ID or exact display name. Ambiguous names fail with candidate IDs instead of guessing."
+  }),
+  card: ProcessCardIdentifier.annotations({
+    description: "Card/document ID or exact title to attach the new execution to. If a title matches multiple cards, the call fails with candidates."
+  })
+}).annotations({
+  title: "StartProcessParams",
+  description: "Parameters for starting a Huly Process workflow execution on a card/document."
+});
+var CancelExecutionParamsSchema = Schema_exports.Struct({
+  execution: ProcessExecutionId.annotations({
+    description: "Process execution ID to cancel. Already-cancelled executions return cancelled=false; completed executions fail without mutation."
+  })
+}).annotations({
+  title: "CancelExecutionParams",
+  description: "Parameters for cancelling an active Huly Process workflow execution."
+});
+var ListProcessesResultSchema = Schema_exports.Struct({
+  processes: Schema_exports.Array(ProcessSummarySchema),
+  total: Schema_exports.NonNegativeInt
+});
+var ListExecutionsResultSchema = Schema_exports.Struct({
+  executions: Schema_exports.Array(ProcessExecutionSummarySchema),
+  total: Schema_exports.NonNegativeInt
+});
+var StartProcessResultSchema = Schema_exports.Struct({
+  executionId: ProcessExecutionId,
+  processId: ProcessId,
+  processName: Schema_exports.optional(NonEmptyString2),
+  cardId: CardId,
+  cardTitle: Schema_exports.optional(NonEmptyString2),
+  currentStateId: ProcessStateId,
+  currentStateTitle: Schema_exports.optional(NonEmptyString2),
+  status: Schema_exports.Literal("active")
+});
+var CancelExecutionResultSchema = Schema_exports.Struct({
+  executionId: ProcessExecutionId,
+  status: Schema_exports.Literal("cancelled"),
+  cancelled: Schema_exports.Boolean
+});
+var listProcessesParamsJsonSchema = JSONSchema_exports.make(ListProcessesParamsSchema);
+var getProcessParamsJsonSchema = JSONSchema_exports.make(GetProcessParamsSchema);
+var listExecutionsParamsJsonSchema = JSONSchema_exports.make(ListExecutionsParamsSchema);
+var startProcessParamsJsonSchema = JSONSchema_exports.make(StartProcessParamsSchema);
+var cancelExecutionParamsJsonSchema = JSONSchema_exports.make(CancelExecutionParamsSchema);
+var parseListProcessesParams = Schema_exports.decodeUnknown(ListProcessesParamsSchema);
+var parseGetProcessParams = Schema_exports.decodeUnknown(GetProcessParamsSchema);
+var parseListExecutionsParams = Schema_exports.decodeUnknown(ListExecutionsParamsSchema);
+var parseStartProcessParams = Schema_exports.decodeUnknown(StartProcessParamsSchema);
+var parseCancelExecutionParams = Schema_exports.decodeUnknown(CancelExecutionParamsSchema);
+
+// src/huly/errors-processes.ts
+var candidateList = (candidates) => candidates.map(
+  (candidate) => candidate.masterTagName === void 0 ? `${candidate.name} (${candidate.id}, masterTag ${candidate.masterTagId})` : `${candidate.name} (${candidate.id}, ${candidate.masterTagName})`
+).join("; ");
+var ProcessNotFoundError = class extends Schema_exports.TaggedError()(
+  "ProcessNotFoundError",
   {
     identifier: Schema_exports.String,
-    project: Schema_exports.String
+    candidates: Schema_exports.Array(ProcessCandidateSchema)
   }
 ) {
   get message() {
-    return `Issue '${this.identifier}' not found in project '${this.project}'`;
+    const suffix = this.candidates.length === 0 ? "" : ` Available processes: ${candidateList(this.candidates)}`;
+    return `Process '${this.identifier}' not found.${suffix}`;
   }
 };
-var ProjectNotFoundError = class extends Schema_exports.TaggedError()(
-  "ProjectNotFoundError",
+var ProcessIdentifierAmbiguousError = class extends Schema_exports.TaggedError()(
+  "ProcessIdentifierAmbiguousError",
   {
-    identifier: Schema_exports.String
+    identifier: Schema_exports.String,
+    candidates: Schema_exports.Array(ProcessCandidateSchema)
   }
 ) {
   get message() {
-    return `Project '${this.identifier}' not found`;
+    return `Process name '${this.identifier}' is ambiguous. Use one of these process IDs: ${candidateList(this.candidates)}`;
   }
 };
-var InvalidStatusError = class extends Schema_exports.TaggedError()(
-  "InvalidStatusError",
+var ProcessMasterTagNotFoundError = class extends Schema_exports.TaggedError()(
+  "ProcessMasterTagNotFoundError",
   {
-    status: Schema_exports.String,
-    project: Schema_exports.String
+    identifier: Schema_exports.String
   }
 ) {
   get message() {
-    return `Invalid status '${this.status}' for project '${this.project}'`;
+    return `Process master tag/card type '${this.identifier}' not found`;
   }
 };
-var CommentNotFoundError = class extends Schema_exports.TaggedError()(
-  "CommentNotFoundError",
+var ProcessMasterTagAmbiguousError = class extends Schema_exports.TaggedError()(
+  "ProcessMasterTagAmbiguousError",
   {
-    commentId: Schema_exports.String,
-    issueIdentifier: Schema_exports.String,
-    project: Schema_exports.String
+    identifier: Schema_exports.String,
+    candidates: Schema_exports.Array(Schema_exports.Struct({
+      id: MasterTagId,
+      name: NonEmptyString2
+    }))
   }
 ) {
   get message() {
-    return `Comment '${this.commentId}' not found on issue '${this.issueIdentifier}' in project '${this.project}'`;
+    const candidates = this.candidates.map((candidate) => `${candidate.name} (${candidate.id})`).join("; ");
+    return `Process master tag/card type '${this.identifier}' is ambiguous. Use one of these IDs: ${candidates}`;
   }
 };
-var MilestoneNotFoundError = class extends Schema_exports.TaggedError()(
-  "MilestoneNotFoundError",
+var ProcessCardIdentifierAmbiguousError = class extends Schema_exports.TaggedError()(
+  "ProcessCardIdentifierAmbiguousError",
   {
     identifier: Schema_exports.String,
-    project: Schema_exports.String
+    candidates: Schema_exports.Array(Schema_exports.Struct({
+      id: CardId,
+      title: NonEmptyString2
+    }))
   }
 ) {
   get message() {
-    return `Milestone '${this.identifier}' not found in project '${this.project}'`;
+    const candidates = this.candidates.map((candidate) => `${candidate.title} (${candidate.id})`).join("; ");
+    return `Card/document title '${this.identifier}' is ambiguous. Use one of these card IDs: ${candidates}`;
   }
 };
-var ComponentNotFoundError = class extends Schema_exports.TaggedError()(
-  "ComponentNotFoundError",
+var ProcessCardNotFoundError = class extends Schema_exports.TaggedError()(
+  "ProcessCardNotFoundError",
   {
-    identifier: Schema_exports.String,
-    project: Schema_exports.String
+    identifier: Schema_exports.String
   }
 ) {
   get message() {
-    return `Component '${this.identifier}' not found in project '${this.project}'`;
+    return `Card/document '${this.identifier}' not found`;
   }
 };
-var IssueTemplateNotFoundError = class extends Schema_exports.TaggedError()(
-  "IssueTemplateNotFoundError",
+var ProcessInitialStateNotFoundError = class extends Schema_exports.TaggedError()(
+  "ProcessInitialStateNotFoundError",
   {
-    identifier: Schema_exports.String,
-    project: Schema_exports.String
+    processId: ProcessId,
+    processName: NonEmptyString2
   }
 ) {
   get message() {
-    return `Issue template '${this.identifier}' not found in project '${this.project}'`;
+    return `Process '${this.processName}' (${this.processId}) has no initial transition from null`;
   }
 };
-var TemplateChildNotFoundError = class extends Schema_exports.TaggedError()(
-  "TemplateChildNotFoundError",
+var ProcessParallelExecutionForbiddenError = class extends Schema_exports.TaggedError()(
+  "ProcessParallelExecutionForbiddenError",
   {
-    childId: Schema_exports.String,
-    template: Schema_exports.String,
-    project: Schema_exports.String
+    processId: ProcessId,
+    cardId: CardId,
+    activeExecutionId: ProcessExecutionId
   }
 ) {
   get message() {
-    return `Child template '${this.childId}' not found in template '${this.template}' of project '${this.project}'`;
+    return `Process '${this.processId}' already has active execution '${this.activeExecutionId}' for card '${this.cardId}'`;
   }
 };
-
-// src/huly/errors.ts
-var HulyDomainError = Schema_exports.Union(
-  HulyError,
-  NoUpdateFieldsError,
-  HulyConnectionError,
-  HulyAuthError,
-  IssueNotFoundError,
-  ProjectNotFoundError,
-  InvalidStatusError,
-  PersonIdentifierAmbiguousError,
-  PersonNotFoundError,
-  OrganizationNotFoundError,
-  OrganizationIdentifierAmbiguousError,
+var ProcessExecutionNotFoundError = class extends Schema_exports.TaggedError()(
+  "ProcessExecutionNotFoundError",
+  {
+    executionId: ProcessExecutionId
+  }
+) {
+  get message() {
+    return `Process execution '${this.executionId}' not found`;
+  }
+};
+var ProcessExecutionNotCancellableError = class extends Schema_exports.TaggedError()(
+  "ProcessExecutionNotCancellableError",
+  {
+    executionId: ProcessExecutionId,
+    status: Schema_exports.Literal("done")
+  }
+) {
+  get message() {
+    return `Process execution '${this.executionId}' is completed and cannot be cancelled`;
+  }
+};
+
+// src/huly/errors-test-management.ts
+var TestProjectNotFoundError = class extends Schema_exports.TaggedError()(
+  "TestProjectNotFoundError",
+  {
+    identifier: Schema_exports.String
+  }
+) {
+  get message() {
+    return `Test project '${this.identifier}' not found`;
+  }
+};
+var TestSuiteNotFoundError = class extends Schema_exports.TaggedError()(
+  "TestSuiteNotFoundError",
+  {
+    identifier: Schema_exports.String
+  }
+) {
+  get message() {
+    return `Test suite '${this.identifier}' not found`;
+  }
+};
+var TestCaseNotFoundError = class extends Schema_exports.TaggedError()(
+  "TestCaseNotFoundError",
+  {
+    identifier: Schema_exports.String
+  }
+) {
+  get message() {
+    return `Test case '${this.identifier}' not found`;
+  }
+};
+var TestPlanNotFoundError = class extends Schema_exports.TaggedError()(
+  "TestPlanNotFoundError",
+  {
+    identifier: Schema_exports.String
+  }
+) {
+  get message() {
+    return `Test plan '${this.identifier}' not found`;
+  }
+};
+var TestRunNotFoundError = class extends Schema_exports.TaggedError()(
+  "TestRunNotFoundError",
+  {
+    identifier: Schema_exports.String
+  }
+) {
+  get message() {
+    return `Test run '${this.identifier}' not found`;
+  }
+};
+var TestResultNotFoundError = class extends Schema_exports.TaggedError()(
+  "TestResultNotFoundError",
+  {
+    identifier: Schema_exports.String
+  }
+) {
+  get message() {
+    return `Test result '${this.identifier}' not found`;
+  }
+};
+var TestPlanItemNotFoundError = class extends Schema_exports.TaggedError()(
+  "TestPlanItemNotFoundError",
+  {
+    identifier: Schema_exports.String,
+    plan: Schema_exports.String
+  }
+) {
+  get message() {
+    return `Test plan item '${this.identifier}' not found in plan '${this.plan}'`;
+  }
+};
+
+// src/huly/errors-tracker.ts
+var IssueNotFoundError = class extends Schema_exports.TaggedError()(
+  "IssueNotFoundError",
+  {
+    identifier: Schema_exports.String,
+    project: Schema_exports.String
+  }
+) {
+  get message() {
+    return `Issue '${this.identifier}' not found in project '${this.project}'`;
+  }
+};
+var ProjectNotFoundError = class extends Schema_exports.TaggedError()(
+  "ProjectNotFoundError",
+  {
+    identifier: Schema_exports.String
+  }
+) {
+  get message() {
+    return `Project '${this.identifier}' not found`;
+  }
+};
+var InvalidStatusError = class extends Schema_exports.TaggedError()(
+  "InvalidStatusError",
+  {
+    status: Schema_exports.String,
+    project: Schema_exports.String
+  }
+) {
+  get message() {
+    return `Invalid status '${this.status}' for project '${this.project}'`;
+  }
+};
+var CommentNotFoundError = class extends Schema_exports.TaggedError()(
+  "CommentNotFoundError",
+  {
+    commentId: Schema_exports.String,
+    issueIdentifier: Schema_exports.String,
+    project: Schema_exports.String
+  }
+) {
+  get message() {
+    return `Comment '${this.commentId}' not found on issue '${this.issueIdentifier}' in project '${this.project}'`;
+  }
+};
+var MilestoneNotFoundError = class extends Schema_exports.TaggedError()(
+  "MilestoneNotFoundError",
+  {
+    identifier: Schema_exports.String,
+    project: Schema_exports.String
+  }
+) {
+  get message() {
+    return `Milestone '${this.identifier}' not found in project '${this.project}'`;
+  }
+};
+var ComponentNotFoundError = class extends Schema_exports.TaggedError()(
+  "ComponentNotFoundError",
+  {
+    identifier: Schema_exports.String,
+    project: Schema_exports.String
+  }
+) {
+  get message() {
+    return `Component '${this.identifier}' not found in project '${this.project}'`;
+  }
+};
+var IssueTemplateNotFoundError = class extends Schema_exports.TaggedError()(
+  "IssueTemplateNotFoundError",
+  {
+    identifier: Schema_exports.String,
+    project: Schema_exports.String
+  }
+) {
+  get message() {
+    return `Issue template '${this.identifier}' not found in project '${this.project}'`;
+  }
+};
+var TemplateChildNotFoundError = class extends Schema_exports.TaggedError()(
+  "TemplateChildNotFoundError",
+  {
+    childId: Schema_exports.String,
+    template: Schema_exports.String,
+    project: Schema_exports.String
+  }
+) {
+  get message() {
+    return `Child template '${this.childId}' not found in template '${this.template}' of project '${this.project}'`;
+  }
+};
+
+// src/huly/errors.ts
+var HulyDomainError = Schema_exports.Union(
+  HulyError,
+  NoUpdateFieldsError,
+  HulyConnectionError,
+  HulyAuthError,
+  IssueNotFoundError,
+  ProjectNotFoundError,
+  InvalidStatusError,
+  PersonIdentifierAmbiguousError,
+  PersonNotFoundError,
+  OrganizationNotFoundError,
+  OrganizationIdentifierAmbiguousError,
   InvalidContactProviderError,
   FileUploadError,
   InvalidFileDataError,
@@ -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.1" : "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",
@@ -175851,352 +176212,116 @@ var deleteEvent = (params) => Effect_exports.gen(function* () {
     return yield* new EventNotFoundError({ eventId: params.eventId });
   }
   yield* client.removeDoc(
-    calendar.class.Event,
-    event.space,
-    event._id
-  );
-  return { eventId: EventId.make(params.eventId), deleted: true };
-});
-
-// src/mcp/tools/calendar.ts
-var CATEGORY3 = "calendar";
-var calendarTools = [
-  {
-    name: "list_events",
-    description: "List calendar events. Returns events sorted by date. Supports filtering by date range.",
-    category: CATEGORY3,
-    inputSchema: listEventsParamsJsonSchema,
-    handler: createToolHandler(
-      "list_events",
-      parseListEventsParams,
-      listEvents
-    )
-  },
-  {
-    name: "list_calendars",
-    description: "List writable, non-hidden calendars that can be used as create_event or create_recurring_event targets. Use this before creating events when you need to choose a target calendarId explicitly.",
-    category: CATEGORY3,
-    inputSchema: listCalendarsParamsJsonSchema,
-    handler: createToolHandler(
-      "list_calendars",
-      parseListCalendarsParams,
-      listCalendars
-    )
-  },
-  {
-    name: "get_event",
-    description: "Retrieve full details for a calendar event including description. Use this to view event content and metadata.",
-    category: CATEGORY3,
-    inputSchema: getEventParamsJsonSchema,
-    handler: createToolHandler(
-      "get_event",
-      parseGetEventParams,
-      getEvent
-    )
-  },
-  {
-    name: "create_event",
-    description: "Create a new calendar event. Description supports markdown formatting. Optional calendarId targets a specific calendar; when omitted, the event uses the authenticated user's primary personal calendar. Returns the created event ID.",
-    category: CATEGORY3,
-    inputSchema: createEventParamsJsonSchema,
-    handler: createToolHandler(
-      "create_event",
-      parseCreateEventParams,
-      createEvent
-    )
-  },
-  {
-    name: "update_event",
-    description: "Update fields on an existing calendar event. Only provided fields are modified. Description updates support markdown.",
-    category: CATEGORY3,
-    inputSchema: updateEventParamsJsonSchema,
-    handler: createToolHandler(
-      "update_event",
-      parseUpdateEventParams,
-      updateEvent
-    )
-  },
-  {
-    name: "delete_event",
-    description: "Permanently delete a calendar event. This action cannot be undone.",
-    category: CATEGORY3,
-    inputSchema: deleteEventParamsJsonSchema,
-    handler: createToolHandler(
-      "delete_event",
-      parseDeleteEventParams,
-      deleteEvent
-    )
-  },
-  {
-    name: "list_recurring_events",
-    description: "List recurring event definitions. Returns recurring events sorted by modification date (newest first).",
-    category: CATEGORY3,
-    inputSchema: listRecurringEventsParamsJsonSchema,
-    handler: createToolHandler(
-      "list_recurring_events",
-      parseListRecurringEventsParams,
-      listRecurringEvents
-    )
-  },
-  {
-    name: "create_recurring_event",
-    description: "Create a new recurring calendar event with RFC5545 RRULE rules. Description supports markdown. Optional calendarId targets a specific calendar; when omitted, the event uses the authenticated user's primary personal calendar. Returns the created event ID.",
-    category: CATEGORY3,
-    inputSchema: createRecurringEventParamsJsonSchema,
-    handler: createToolHandler(
-      "create_recurring_event",
-      parseCreateRecurringEventParams,
-      createRecurringEvent
-    )
-  },
-  {
-    name: "list_event_instances",
-    description: "List instances of a recurring event. Returns instances sorted by date. Supports filtering by date range. Use includeParticipants=true to fetch full participant info (extra lookups).",
-    category: CATEGORY3,
-    inputSchema: listEventInstancesParamsJsonSchema,
-    handler: createToolHandler(
-      "list_event_instances",
-      parseListEventInstancesParams,
-      listEventInstances
-    )
-  }
-];
-
-// 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);
+    calendar.class.Event,
+    event.space,
+    event._id
+  );
+  return { eventId: EventId.make(params.eventId), deleted: true };
+});
+
+// src/mcp/tools/calendar.ts
+var CATEGORY3 = "calendar";
+var calendarTools = [
+  {
+    name: "list_events",
+    description: "List calendar events. Returns events sorted by date. Supports filtering by date range.",
+    category: CATEGORY3,
+    inputSchema: listEventsParamsJsonSchema,
+    handler: createToolHandler(
+      "list_events",
+      parseListEventsParams,
+      listEvents
+    )
+  },
+  {
+    name: "list_calendars",
+    description: "List writable, non-hidden calendars that can be used as create_event or create_recurring_event targets. Use this before creating events when you need to choose a target calendarId explicitly.",
+    category: CATEGORY3,
+    inputSchema: listCalendarsParamsJsonSchema,
+    handler: createToolHandler(
+      "list_calendars",
+      parseListCalendarsParams,
+      listCalendars
+    )
+  },
+  {
+    name: "get_event",
+    description: "Retrieve full details for a calendar event including description. Use this to view event content and metadata.",
+    category: CATEGORY3,
+    inputSchema: getEventParamsJsonSchema,
+    handler: createToolHandler(
+      "get_event",
+      parseGetEventParams,
+      getEvent
+    )
+  },
+  {
+    name: "create_event",
+    description: "Create a new calendar event. Description supports markdown formatting. Optional calendarId targets a specific calendar; when omitted, the event uses the authenticated user's primary personal calendar. Returns the created event ID.",
+    category: CATEGORY3,
+    inputSchema: createEventParamsJsonSchema,
+    handler: createToolHandler(
+      "create_event",
+      parseCreateEventParams,
+      createEvent
+    )
+  },
+  {
+    name: "update_event",
+    description: "Update fields on an existing calendar event. Only provided fields are modified. Description updates support markdown.",
+    category: CATEGORY3,
+    inputSchema: updateEventParamsJsonSchema,
+    handler: createToolHandler(
+      "update_event",
+      parseUpdateEventParams,
+      updateEvent
+    )
+  },
+  {
+    name: "delete_event",
+    description: "Permanently delete a calendar event. This action cannot be undone.",
+    category: CATEGORY3,
+    inputSchema: deleteEventParamsJsonSchema,
+    handler: createToolHandler(
+      "delete_event",
+      parseDeleteEventParams,
+      deleteEvent
+    )
+  },
+  {
+    name: "list_recurring_events",
+    description: "List recurring event definitions. Returns recurring events sorted by modification date (newest first).",
+    category: CATEGORY3,
+    inputSchema: listRecurringEventsParamsJsonSchema,
+    handler: createToolHandler(
+      "list_recurring_events",
+      parseListRecurringEventsParams,
+      listRecurringEvents
+    )
+  },
+  {
+    name: "create_recurring_event",
+    description: "Create a new recurring calendar event with RFC5545 RRULE rules. Description supports markdown. Optional calendarId targets a specific calendar; when omitted, the event uses the authenticated user's primary personal calendar. Returns the created event ID.",
+    category: CATEGORY3,
+    inputSchema: createRecurringEventParamsJsonSchema,
+    handler: createToolHandler(
+      "create_recurring_event",
+      parseCreateRecurringEventParams,
+      createRecurringEvent
+    )
+  },
+  {
+    name: "list_event_instances",
+    description: "List instances of a recurring event. Returns instances sorted by date. Supports filtering by date range. Use includeParticipants=true to fetch full participant info (extra lookups).",
+    category: CATEGORY3,
+    inputSchema: listEventInstancesParamsJsonSchema,
+    handler: createToolHandler(
+      "list_event_instances",
+      parseListEventInstancesParams,
+      listEventInstances
+    )
+  }
+];
 
 // src/domain/schemas/projects.ts
 var ProjectSummarySchema = Schema_exports.Struct({
@@ -182115,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.`
@@ -182131,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)
@@ -182150,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",
@@ -182160,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();
@@ -182203,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 = {};
@@ -182300,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) {
@@ -182514,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,
@@ -182752,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
@@ -182784,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.",
@@ -182798,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: {
@@ -182816,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,